def _opt_project_on_detector(angs, rD, rC, gVec_cs, rMat_ss, tD, tC, tS, distortion):
tmp_xys = xfcapi.gvecToDetectorXYArray(gVec_cs, rD, rMat_ss, rC, tD, tS, tC)
# do not filter nans, let the code after it handle that.
# filter nans...
#tmp_xys = _filter_nans(tmp_xys)
if distortion is not None and len(distortion) > 0:
tmp_xys = distortion[0](tmp_xys, distortion[1], invert=True)
return tmp_xys, None
def _opt_project_on_detector(angs, rD, rC, gVec_cs, rMat_ss, tD, tC, tS,
distortion):
tmp_xys = xfcapi.gvecToDetectorXYArray(gVec_cs, rD, rMat_ss, rC, tD, tS,
tC)
# do not filter nans, let the code after it handle that.
# filter nans...
#tmp_xys = _filter_nans(tmp_xys)
if distortion is not None and len(distortion) > 0:
tmp_xys = distortion[0](tmp_xys, distortion[1], invert=True)
return tmp_xys, None
def objFuncFitGrain(gFit,
gFull,
gFlag,
detectorParams,
xyo_det,
hkls_idx,
bMat,
wavelength,
bVec,
eVec,
dFunc,
dParams,
omePeriod,
simOnly=False,
return_value_flag=return_value_flag):
"""
gFull[0] = expMap_c[0]
gFull[1] = expMap_c[1]
gFull[2] = expMap_c[2]
gFull[3] = tVec_c[0]
gFull[4] = tVec_c[1]
gFull[5] = tVec_c[2]
gFull[6] = vInv_MV[0]
gFull[7] = vInv_MV[1]
gFull[8] = vInv_MV[2]
gFull[9] = vInv_MV[3]
gFull[10] = vInv_MV[4]
gFull[11] = vInv_MV[5]
detectorParams[0] = tiltAngles[0]
detectorParams[1] = tiltAngles[1]
detectorParams[2] = tiltAngles[2]
detectorParams[3] = tVec_d[0]
detectorParams[4] = tVec_d[1]
detectorParams[5] = tVec_d[2]
detectorParams[6] = chi
detectorParams[7] = tVec_s[0]
detectorParams[8] = tVec_s[1]
detectorParams[9] = tVec_s[2]
"""
npts = len(xyo_det)
gFull[gFlag] = gFit
xy_unwarped = dFunc(xyo_det[:, :2], dParams)
rMat_d = xfcapi.makeDetectorRotMat(detectorParams[:3])
tVec_d = detectorParams[3:6].reshape(3, 1)
chi = detectorParams[6]
tVec_s = detectorParams[7:10].reshape(3, 1)
rMat_c = xfcapi.makeRotMatOfExpMap(gFull[:3])
tVec_c = gFull[3:6].reshape(3, 1)
vInv_s = gFull[6:]
vMat_s = mutil.vecMVToSymm(vInv_s) # NOTE: Inverse of V from F = V * R
gVec_c = np.dot(bMat, hkls_idx) # gVecs with magnitudes in CRYSTAL frame
gVec_s = np.dot(vMat_s, np.dot(rMat_c,
gVec_c)) # stretched gVecs in SAMPLE frame
gHat_c = mutil.unitVector(np.dot(
rMat_c.T, gVec_s)) # unit reciprocal lattice vectors in CRYSTAL frame
match_omes, calc_omes = matchOmegas(xyo_det,
hkls_idx,
chi,
rMat_c,
bMat,
wavelength,
vInv=vInv_s,
beamVec=bVec,
etaVec=eVec,
omePeriod=omePeriod)
rMat_s = xfcapi.makeOscillRotMatArray(chi, calc_omes)
calc_xy = xfcapi.gvecToDetectorXYArray(gHat_c.T,
rMat_d,
rMat_s,
rMat_c,
tVec_d,
tVec_s,
tVec_c,
beamVec=bVec)
if np.any(np.isnan(calc_xy)):
print "infeasible pFull"
# return values
if simOnly:
retval = np.hstack([calc_xy, calc_omes.reshape(npts, 1)])
else:
diff_vecs_xy = calc_xy - xy_unwarped[:, :2]
diff_ome = xf.angularDifference(calc_omes, xyo_det[:, 2])
retval = np.hstack([diff_vecs_xy, diff_ome.reshape(npts, 1)]).flatten()
if return_value_flag == 1:
retval = sum(abs(retval))
elif return_value_flag == 2:
denom = npts - len(gFit) - 1.
if denom != 0:
nu_fac = 1. / denom
else:
nu_fac = 1.
retval = nu_fac * sum(retval**2 / abs(
np.hstack([calc_xy, calc_omes.reshape(npts, 1)]).flatten()))
return retval
def sxcal_obj_func(plist_fit,
plist_full,
param_flags,
dfuncs,
dparam_flags,
ndparams,
instr,
xyo_det,
hkls_idx,
bmat,
vinv_s,
ome_period,
bvec,
evec,
sim_only=False,
return_value_flag=None):
"""
"""
# stack flags and force bool repr
refine_flags = np.array(np.hstack([param_flags, dparam_flags]), dtype=bool)
# fill out full parameter list
# !!! no scaling for now
plist_full[refine_flags] = plist_fit
# instrument quantities
wavelength = plist_full[0]
chi = plist_full[1]
tvec_s = plist_full[2:5]
# calibration crystal quantities
rmat_c = xfcapi.makeRotMatOfExpMap(plist_full[5:8])
tvec_c = plist_full[8:11]
# right now just stuck on the end and assumed
# to all be the same length... FIX THIS
dparams_all = plist_full[-len(dparam_flags):]
xy_unwarped = {}
meas_omes = {}
calc_omes = {}
calc_xy = {}
ii = 11 # offset to start of panels...
jj = 0
npts_tot = 0
for det_key, panel in instr.detectors.iteritems():
xy_unwarped[det_key] = xyo_det[det_key][:, :2]
npts_tot += len(xyo_det[det_key])
dfunc = dfuncs[det_key]
len_these_dps = ndparams[det_key]
if dfunc is not None: # do unwarping
dparams = dparams_all[jj:jj + len_these_dps]
jj += len_these_dps
xy_unwarped[det_key] = dfunc(xy_unwarped[det_key], dparams)
pass
meas_omes[det_key] = xyo_det[det_key][:, 2]
# get these panel params for convenience
gparams = plist_full[ii:ii + 6]
rmat_d = xfcapi.makeDetectorRotMat(gparams[:3])
tvec_d = gparams[3:].reshape(3, 1)
# transform G-vectors:
# 1) convert inv. stretch tensor from MV notation in to 3x3
# 2) take reciprocal lattice vectors from CRYSTAL to SAMPLE frame
# 3) apply stretch tensor
# 4) normalize reciprocal lattice vectors in SAMPLE frame
# 5) transform unit reciprocal lattice vetors back to CRYSAL frame
gvec_c = np.dot(bmat, hkls_idx[det_key].T)
vmat_s = mutil.vecMVToSymm(vinv_s)
ghat_s = mutil.unitVector(np.dot(vmat_s, np.dot(rmat_c, gvec_c)))
ghat_c = np.dot(rmat_c.T, ghat_s)
match_omes, calc_omes_tmp = fitting.matchOmegas(xyo_det[det_key],
hkls_idx[det_key].T,
chi,
rmat_c,
bmat,
wavelength,
vInv=vinv_s,
beamVec=bvec,
etaVec=evec,
omePeriod=ome_period)
rmat_s_arr = xfcapi.makeOscillRotMatArray(
chi, np.ascontiguousarray(calc_omes_tmp))
calc_xy_tmp = xfcapi.gvecToDetectorXYArray(ghat_c.T, rmat_d,
rmat_s_arr, rmat_c, tvec_d,
tvec_s, tvec_c)
if np.any(np.isnan(calc_xy_tmp)):
print("infeasible parameters: " +
"may want to scale back finite difference step size")
calc_omes[det_key] = calc_omes_tmp
calc_xy[det_key] = calc_xy_tmp
ii += 6
pass
# return values
if sim_only:
retval = {}
for det_key in calc_xy.keys():
# ??? calc_xy is always 2-d
retval[det_key] = np.vstack(
[calc_xy[det_key].T, calc_omes[det_key]]).T
else:
meas_xy_all = []
calc_xy_all = []
meas_omes_all = []
calc_omes_all = []
for det_key in xy_unwarped.keys():
meas_xy_all.append(xy_unwarped[det_key])
calc_xy_all.append(calc_xy[det_key])
meas_omes_all.append(meas_omes[det_key])
calc_omes_all.append(calc_omes[det_key])
pass
meas_xy_all = np.vstack(meas_xy_all)
calc_xy_all = np.vstack(calc_xy_all)
meas_omes_all = np.hstack(meas_omes_all)
calc_omes_all = np.hstack(calc_omes_all)
diff_vecs_xy = calc_xy_all - meas_xy_all
diff_ome = xfcapi.angularDifference(calc_omes_all, meas_omes_all)
retval = np.hstack([diff_vecs_xy,
diff_ome.reshape(npts_tot, 1)]).flatten()
if return_value_flag == 1:
retval = sum(abs(retval))
elif return_value_flag == 2:
denom = npts_tot - len(plist_fit) - 1.
if denom != 0:
nu_fac = 1. / denom
else:
nu_fac = 1.
nu_fac = 1 / (npts_tot - len(plist_fit) - 1.)
retval = nu_fac * sum(retval**2)
return retval
def objFuncFitGrain(gFit, gFull, gFlag,
detectorParams,
xyo_det, hkls_idx, bMat, wavelength,
bVec, eVec,
dFunc, dParams,
omePeriod,
simOnly=False, return_value_flag=return_value_flag):
"""
gFull[0] = expMap_c[0]
gFull[1] = expMap_c[1]
gFull[2] = expMap_c[2]
gFull[3] = tVec_c[0]
gFull[4] = tVec_c[1]
gFull[5] = tVec_c[2]
gFull[6] = vInv_MV[0]
gFull[7] = vInv_MV[1]
gFull[8] = vInv_MV[2]
gFull[9] = vInv_MV[3]
gFull[10] = vInv_MV[4]
gFull[11] = vInv_MV[5]
detectorParams[0] = tiltAngles[0]
detectorParams[1] = tiltAngles[1]
detectorParams[2] = tiltAngles[2]
detectorParams[3] = tVec_d[0]
detectorParams[4] = tVec_d[1]
detectorParams[5] = tVec_d[2]
detectorParams[6] = chi
detectorParams[7] = tVec_s[0]
detectorParams[8] = tVec_s[1]
detectorParams[9] = tVec_s[2]
"""
npts = len(xyo_det)
gFull[gFlag] = gFit
xy_unwarped = dFunc(xyo_det[:, :2], dParams)
rMat_d = xfcapi.makeDetectorRotMat(detectorParams[:3])
tVec_d = detectorParams[3:6].reshape(3, 1)
chi = detectorParams[6]
tVec_s = detectorParams[7:10].reshape(3, 1)
rMat_c = xfcapi.makeRotMatOfExpMap(gFull[:3])
tVec_c = gFull[3:6].reshape(3, 1)
vInv_s = gFull[6:]
vMat_s = mutil.vecMVToSymm(vInv_s) # NOTE: Inverse of V from F = V * R
gVec_c = np.dot(bMat, hkls_idx) # gVecs with magnitudes in CRYSTAL frame
gVec_s = np.dot(vMat_s, np.dot(rMat_c, gVec_c)) # stretched gVecs in SAMPLE frame
gHat_c = mutil.unitVector(
np.dot(rMat_c.T, gVec_s)) # unit reciprocal lattice vectors in CRYSTAL frame
match_omes, calc_omes = matchOmegas(xyo_det, hkls_idx, chi, rMat_c, bMat, wavelength,
vInv=vInv_s, beamVec=bVec, etaVec=eVec,
omePeriod=omePeriod)
rMat_s = xfcapi.makeOscillRotMatArray(chi, calc_omes)
calc_xy = xfcapi.gvecToDetectorXYArray(gHat_c.T,
rMat_d, rMat_s, rMat_c,
tVec_d, tVec_s, tVec_c,
beamVec=bVec)
if np.any(np.isnan(calc_xy)):
print "infeasible pFull"
# return values
if simOnly:
retval = np.hstack([calc_xy, calc_omes.reshape(npts, 1)])
else:
diff_vecs_xy = calc_xy - xy_unwarped[:, :2]
diff_ome = xf.angularDifference( calc_omes, xyo_det[:, 2] )
retval = np.hstack([diff_vecs_xy,
diff_ome.reshape(npts, 1)
]).flatten()
if return_value_flag == 1:
retval = sum( abs(retval) )
elif return_value_flag == 2:
denom = npts - len(gFit) - 1.
if denom != 0:
nu_fac = 1. / denom
else:
nu_fac = 1.
retval = nu_fac * sum(retval**2 / abs(np.hstack([calc_xy, calc_omes.reshape(npts, 1)]).flatten()))
return retval
def objFuncFitGrain(gFit, gFull, gFlag,
instrument,
reflections_dict,
bMat, wavelength,
omePeriod,
simOnly=False,
return_value_flag=return_value_flag):
"""
gFull[0] = expMap_c[0]
gFull[1] = expMap_c[1]
gFull[2] = expMap_c[2]
gFull[3] = tVec_c[0]
gFull[4] = tVec_c[1]
gFull[5] = tVec_c[2]
gFull[6] = vInv_MV[0]
gFull[7] = vInv_MV[1]
gFull[8] = vInv_MV[2]
gFull[9] = vInv_MV[3]
gFull[10] = vInv_MV[4]
gFull[11] = vInv_MV[5]
OLD CALL
objFuncFitGrain(gFit, gFull, gFlag,
detectorParams,
xyo_det, hkls_idx, bMat, wavelength,
bVec, eVec,
dFunc, dParams,
omePeriod,
simOnly=False, return_value_flag=return_value_flag)
"""
bVec = instrument.beam_vector
eVec = instrument.eta_vector
# fill out parameters
gFull[gFlag] = gFit
# map parameters to functional arrays
rMat_c = xfcapi.makeRotMatOfExpMap(gFull[:3])
tVec_c = gFull[3:6].reshape(3, 1)
vInv_s = gFull[6:]
vMat_s = mutil.vecMVToSymm(vInv_s) # NOTE: Inverse of V from F = V * R
# loop over instrument panels
# CAVEAT: keeping track of key ordering in the "detectors" attribute of
# instrument here because I am not sure if instatiating them using
# dict.fromkeys() preserves the same order if using iteration...
# <JVB 2017-10-31>
calc_omes_dict = dict.fromkeys(instrument.detectors, [])
calc_xy_dict = dict.fromkeys(instrument.detectors)
meas_xyo_all = []
det_keys_ordered = []
for det_key, panel in instrument.detectors.iteritems():
det_keys_ordered.append(det_key)
rMat_d, tVec_d, chi, tVec_s = extract_detector_transformation(
instrument.detector_parameters[det_key])
results = reflections_dict[det_key]
if len(results) == 0:
continue
"""
extract data from results list fields:
refl_id, gvec_id, hkl, sum_int, max_int, pred_ang, meas_ang, meas_xy
or array from spots tables:
0:5 ID PID H K L
5:7 sum(int) max(int)
7:10 pred tth pred eta pred ome
10:13 meas tth meas eta meas ome
13:15 pred X pred Y
15:17 meas X meas Y
"""
if isinstance(results, list):
# WARNING: hkls and derived vectors below must be columnwise;
# strictly necessary??? change affected APIs instead?
# <JVB 2017-03-26>
hkls = np.atleast_2d(
np.vstack([x[2] for x in results])
).T
meas_xyo = np.atleast_2d(
np.vstack([np.r_[x[7], x[6][-1]] for x in results])
)
elif isinstance(results, np.ndarray):
hkls = np.atleast_2d(results[:, 2:5]).T
meas_xyo = np.atleast_2d(results[:, [15, 16, 12]])
# FIXME: distortion handling must change to class-based
if panel.distortion is not None:
meas_omes = meas_xyo[:, 2]
xy_unwarped = panel.distortion[0](
meas_xyo[:, :2], panel.distortion[1])
meas_xyo = np.vstack([xy_unwarped.T, meas_omes]).T
pass
# append to meas_omes
meas_xyo_all.append(meas_xyo)
# G-vectors:
# 1. calculate full g-vector components in CRYSTAL frame from B
# 2. rotate into SAMPLE frame and apply stretch
# 3. rotate back into CRYSTAL frame and normalize to unit magnitude
# IDEA: make a function for this sequence of operations with option for
# choosing ouput frame (i.e. CRYSTAL vs SAMPLE vs LAB)
gVec_c = np.dot(bMat, hkls)
gVec_s = np.dot(vMat_s, np.dot(rMat_c, gVec_c))
gHat_c = mutil.unitVector(np.dot(rMat_c.T, gVec_s))
# !!!: check that this operates on UNWARPED xy
match_omes, calc_omes = matchOmegas(
meas_xyo, hkls, chi, rMat_c, bMat, wavelength,
vInv=vInv_s, beamVec=bVec, etaVec=eVec,
omePeriod=omePeriod)
# append to omes dict
calc_omes_dict[det_key] = calc_omes
# TODO: try Numba implementations
rMat_s = xfcapi.makeOscillRotMatArray(chi, calc_omes)
calc_xy = xfcapi.gvecToDetectorXYArray(gHat_c.T,
rMat_d, rMat_s, rMat_c,
tVec_d, tVec_s, tVec_c,
beamVec=bVec)
# append to xy dict
calc_xy_dict[det_key] = calc_xy
pass
# stack results to concatenated arrays
calc_omes_all = np.hstack([calc_omes_dict[k] for k in det_keys_ordered])
tmp = []
for k in det_keys_ordered:
if calc_xy_dict[k] is not None:
tmp.append(calc_xy_dict[k])
calc_xy_all = np.vstack(tmp)
meas_xyo_all = np.vstack(meas_xyo_all)
npts = len(meas_xyo_all)
if np.any(np.isnan(calc_xy)):
raise RuntimeError(
"infeasible pFull: may want to scale" +
"back finite difference step size")
# return values
if simOnly:
# return simulated values
if return_value_flag in [None, 1]:
retval = np.hstack([calc_xy_all, calc_omes_all.reshape(npts, 1)])
else:
rd = dict.fromkeys(det_keys_ordered)
for det_key in det_keys_ordered:
rd[det_key] = {'calc_xy': calc_xy_dict[det_key],
'calc_omes': calc_omes_dict[det_key]}
retval = rd
else:
# return residual vector
# IDEA: try angles instead of xys?
diff_vecs_xy = calc_xy_all - meas_xyo_all[:, :2]
diff_ome = xf.angularDifference(calc_omes_all, meas_xyo_all[:, 2])
retval = np.hstack([diff_vecs_xy,
diff_ome.reshape(npts, 1)
]).flatten()
if return_value_flag == 1:
# return scalar sum of squared residuals
retval = sum(abs(retval))
elif return_value_flag == 2:
# return DOF-normalized chisq
# TODO: check this calculation
denom = 3*npts - len(gFit) - 1.
if denom != 0:
nu_fac = 1. / denom
else:
nu_fac = 1.
retval = nu_fac * sum(retval**2)
return retval
def objFuncFitGrain(gFit,
gFull,
gFlag,
instrument,
reflections_dict,
bMat,
wavelength,
omePeriod,
simOnly=False,
return_value_flag=return_value_flag):
"""
gFull[0] = expMap_c[0]
gFull[1] = expMap_c[1]
gFull[2] = expMap_c[2]
gFull[3] = tVec_c[0]
gFull[4] = tVec_c[1]
gFull[5] = tVec_c[2]
gFull[6] = vInv_MV[0]
gFull[7] = vInv_MV[1]
gFull[8] = vInv_MV[2]
gFull[9] = vInv_MV[3]
gFull[10] = vInv_MV[4]
gFull[11] = vInv_MV[5]
OLD CALL
objFuncFitGrain(gFit, gFull, gFlag,
detectorParams,
xyo_det, hkls_idx, bMat, wavelength,
bVec, eVec,
dFunc, dParams,
omePeriod,
simOnly=False, return_value_flag=return_value_flag)
"""
bVec = instrument.beam_vector
eVec = instrument.eta_vector
# fill out parameters
gFull[gFlag] = gFit
# map parameters to functional arrays
rMat_c = xfcapi.makeRotMatOfExpMap(gFull[:3])
tVec_c = gFull[3:6].reshape(3, 1)
vInv_s = gFull[6:]
vMat_s = mutil.vecMVToSymm(vInv_s) # NOTE: Inverse of V from F = V * R
# loop over instrument panels
# CAVEAT: keeping track of key ordering in the "detectors" attribute of
# instrument here because I am not sure if instatiating them using
# dict.fromkeys() preserves the same order if using iteration...
# <JVB 2017-10-31>
calc_omes_dict = dict.fromkeys(instrument.detectors, [])
calc_xy_dict = dict.fromkeys(instrument.detectors)
meas_xyo_all = []
det_keys_ordered = []
for det_key, panel in instrument.detectors.iteritems():
det_keys_ordered.append(det_key)
# extract transformation quantities
rMat_d = instrument.detectors[det_key].rmat
tVec_d = instrument.detectors[det_key].tvec
chi = instrument.chi
tVec_s = instrument.tvec
results = reflections_dict[det_key]
if len(results) == 0:
continue
"""
extract data from results list
fields:
refl_id, gvec_id, hkl, sum_int, max_int, pred_ang, meas_ang, meas_xy
"""
# WARNING: hkls and derived vectors below must be columnwise;
# strictly necessary??? change affected APIs instead?
# <JVB 2017-03-26>
hkls = np.atleast_2d(np.vstack([x[2] for x in results])).T
meas_xyo = np.atleast_2d(
np.vstack([np.r_[x[7], x[6][-1]] for x in results]))
# FIXME: distortion handling must change to class-based
if panel.distortion is not None:
meas_omes = meas_xyo[:, 2]
xy_unwarped = panel.distortion[0](meas_xyo[:, :2],
panel.distortion[1])
meas_xyo = np.vstack([xy_unwarped.T, meas_omes]).T
pass
# append to meas_omes
meas_xyo_all.append(meas_xyo)
# G-vectors:
# 1. calculate full g-vector components in CRYSTAL frame from B
# 2. rotate into SAMPLE frame and apply stretch
# 3. rotate back into CRYSTAL frame and normalize to unit magnitude
# IDEA: make a function for this sequence of operations with option for
# choosing ouput frame (i.e. CRYSTAL vs SAMPLE vs LAB)
gVec_c = np.dot(bMat, hkls)
gVec_s = np.dot(vMat_s, np.dot(rMat_c, gVec_c))
gHat_c = mutil.unitVector(np.dot(rMat_c.T, gVec_s))
# !!!: check that this operates on UNWARPED xy
match_omes, calc_omes = matchOmegas(meas_xyo,
hkls,
chi,
rMat_c,
bMat,
wavelength,
vInv=vInv_s,
beamVec=bVec,
etaVec=eVec,
omePeriod=omePeriod)
# append to omes dict
calc_omes_dict[det_key] = calc_omes
# TODO: try Numba implementations
rMat_s = xfcapi.makeOscillRotMatArray(chi, calc_omes)
calc_xy = xfcapi.gvecToDetectorXYArray(gHat_c.T,
rMat_d,
rMat_s,
rMat_c,
tVec_d,
tVec_s,
tVec_c,
beamVec=bVec)
# append to xy dict
calc_xy_dict[det_key] = calc_xy
pass
# stack results to concatenated arrays
calc_omes_all = np.hstack([calc_omes_dict[k] for k in det_keys_ordered])
tmp = []
for k in det_keys_ordered:
if calc_xy_dict[k] is not None:
tmp.append(calc_xy_dict[k])
calc_xy_all = np.vstack(tmp)
meas_xyo_all = np.vstack(meas_xyo_all)
npts = len(meas_xyo_all)
if np.any(np.isnan(calc_xy)):
raise RuntimeError("infeasible pFull: may want to scale" +
"back finite difference step size")
# return values
if simOnly:
# return simulated values
if return_value_flag in [None, 1]:
retval = np.hstack([calc_xy_all, calc_omes_all.reshape(npts, 1)])
else:
rd = dict.fromkeys(det_keys_ordered)
for det_key in det_keys_ordered:
rd[det_key] = {
'calc_xy': calc_xy_dict[det_key],
'calc_omes': calc_omes_dict[det_key]
}
retval = rd
else:
# return residual vector
# IDEA: try angles instead of xys?
diff_vecs_xy = calc_xy_all - meas_xyo_all[:, :2]
diff_ome = xf.angularDifference(calc_omes_all, meas_xyo_all[:, 2])
retval = np.hstack([diff_vecs_xy, diff_ome.reshape(npts, 1)]).flatten()
if return_value_flag == 1:
# return scalar sum of squared residuals
retval = sum(abs(retval))
elif return_value_flag == 2:
# return DOF-normalized chisq
# TODO: check this calculation
denom = 3 * npts - len(gFit) - 1.
if denom != 0:
nu_fac = 1. / denom
else:
nu_fac = 1.
retval = nu_fac * sum(retval**2)
return retval