def test_fitz_c_5():
"""
Test that fitz_c.wXwYCurveDistance works correctly.
"""
# Load 3D parameters.
settings = storm_analysis.getData("test/data/test_3d_3d.xml")
parameters = params.ParametersDAO().initFromFile(settings)
[wx_params, wy_params] = parameters.getWidthParams()
[min_z, max_z] = parameters.getZRange()
pixel_size = parameters.getAttr("pixel_size")
# Calculate widths.
z_vals = numpy.arange(-250.0, 251.0, 50)
[sx, sy] = fitzC.calcSxSy(wx_params, wy_params, z_vals)
# Distances should be very close to zero.
dist = fitzC.wXwYCurveDistance(wx_params, wy_params, 2.0 * sx, 2.0 * sy,
min_z, max_z, 0.001)
assert numpy.allclose(dist, numpy.zeros(sx.size))
# First distance should be larger.
sx[0] += 10.0
dist = fitzC.wXwYCurveDistance(wx_params, wy_params, 2.0 * sx, 2.0 * sy,
min_z, max_z, 0.001)
expected = numpy.zeros(sx.size)
expected[0] = 0.0345862
assert numpy.allclose(dist, expected)
def trackAverageCorrect(input_file, output_file, params_file):
parameters = params.ParametersDAO().initFromFile(params_file)
# Tracking
print("Tracking")
std_analysis.tracking(input_file, parameters)
# Averaging
print("Averaging")
did_averaging = False
if (parameters.getAttr("radius") > 0.0):
did_averaging = True
std_analysis.averaging(input_file, output_file)
print("")
# Z fitting.
if (parameters.getAttr("do_zfit", 0) != 0):
print("Fitting Z")
std_analysis.zFitting(input_file, parameters)
std_analysis.zFitting(output_file, parameters)
print("")
# Drift correction
print("Drift Correction")
if (parameters.getAttr("drift_correction", 0) != 0):
if did_averaging:
std_analysis.driftCorrection([input_file, output_file], parameters)
else:
std_analysis.driftCorrection([input_file], parameters)
print("")
def testingParameters():
"""
Create a 3D-DAOSTORM parameters object.
"""
params = parameters.ParametersDAO()
params.setAttr("max_frame", "int", -1)
params.setAttr("start_frame", "int", -1)
params.setAttr("background_sigma", "float", 8.0)
params.setAttr("camera_gain", "float", settings.camera_gain)
params.setAttr("camera_offset", "float", settings.camera_offset)
params.setAttr("find_max_radius", "int", 5)
params.setAttr("foreground_sigma", "float", 1.0)
params.setAttr("iterations", "int", settings.iterations)
params.setAttr("model", "string", settings.model)
params.setAttr("pixel_size", "float", settings.pixel_size)
params.setAttr("roi_size", "int", 9)
params.setAttr("sigma", "float", 1.5)
params.setAttr("threshold", "float", 6.0)
# Do tracking.
params.setAttr("descriptor", "string", "1")
params.setAttr("radius", "float", "0.5")
# Do drift-correction.
params.setAttr("d_scale", "int", 2)
params.setAttr("drift_correction", "int", 1)
params.setAttr("frame_step", "int", 500)
params.setAttr("z_correction", "int", 1)
return params
def test_xml_round_trip():
original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml")
output = storm_analysis.getPathOutputTest("test_rt.xml")
# Load parameters.
p1 = params.ParametersDAO().initFromFile(original, warnings=True)
# Convert back to XML.
p1.toXMLFile(output)
# And read again.
p2 = params.ParametersDAO().initFromFile(output, warnings=True)
# And compare.
if (p1.getAttr("threshold") != p2.getAttr("threshold")):
raise Exception("Parameter XML input / output failed.")
def createParametersFile():
"""
Create a 3D-DAOSTORM parameters file.
"""
params = parameters.ParametersDAO()
params.setAttr("max_frame", "int", -1)
params.setAttr("start_frame", "int", -1)
params.setAttr("background_sigma", "float", 8.0)
params.setAttr("camera_gain", "float", camera_gain)
params.setAttr("camera_offset", "float", camera_offset)
params.setAttr("find_max_radius", "int", 5)
params.setAttr("foreground_sigma", "float", 1.0)
params.setAttr("iterations", "int", 1)
params.setAttr("model", "string", model)
params.setAttr("pixel_size", "float", pixel_size)
params.setAttr("peak_locations", "filename", "peak_locs.hdf5")
params.setAttr("roi_size", "int", 9)
params.setAttr("sigma", "float", 1.5)
params.setAttr("threshold", "float", 6.0)
# Z fitting.
params.setAttr("do_zfit", "int", 0)
params.setAttr("cutoff", "float", 0.0)
params.setAttr("max_z", "float", 0.5)
params.setAttr("min_z", "float", -0.5)
params.setAttr("z_value", "float", 0.0)
params.setAttr("z_step", "float", 0.001)
params.setAttr("wx_wo", "float", 300.0)
params.setAttr("wx_c", "float", 150.0)
params.setAttr("wx_d", "float", 400.0)
params.setAttr("wxA", "float", 0.0)
params.setAttr("wxB", "float", 0.0)
params.setAttr("wxC", "float", 0.0)
params.setAttr("wxD", "float", 0.0)
params.setAttr("wy_wo", "float", 300.0)
params.setAttr("wy_c", "float", -150.0)
params.setAttr("wy_d", "float", 400.0)
params.setAttr("wyA", "float", 0.0)
params.setAttr("wyB", "float", 0.0)
params.setAttr("wyC", "float", 0.0)
params.setAttr("wyD", "float", 0.0)
# Do tracking.
params.setAttr("descriptor", "string", "1")
params.setAttr("radius", "float", "0.5")
# Do drift-correction.
params.setAttr("d_scale", "int", 2)
params.setAttr("drift_correction", "int", 1)
params.setAttr("frame_step", "int", 500)
params.setAttr("z_correction", "int", 0)
params.toXMLFile("dao3d_crao.xml")
def daoSTORMXML():
"""
Create a 3D-DAOSTORM parameters object.
"""
params = parameters.ParametersDAO()
params.setAttr("max_frame", "int", -1)
params.setAttr("start_frame", "int", -1)
params.setAttr("background_sigma", "float", 8.0)
params.setAttr("camera_gain", "float", 1.0)
params.setAttr("camera_offset", "float", camera_offset)
params.setAttr("find_max_radius", "int", 5)
params.setAttr("foreground_sigma", "float", 1.0)
params.setAttr("iterations", "int", iterations)
params.setAttr("model", "string", "2dfixed")
params.setAttr("pixel_size", "float", pixel_size)
params.setAttr("roi_size", "int", 9)
params.setAttr("sigma", "float", 1.5)
params.setAttr("threshold", "float", threshold)
# Don't do tracking.
params.setAttr("descriptor", "string", "1")
params.setAttr("radius", "float", "0")
# Don't do drift-correction.
params.setAttr("d_scale", "int", 2)
params.setAttr("drift_correction", "int", 0)
params.setAttr("frame_step", "int", 500)
params.setAttr("z_correction", "int", 0)
# Z fitting.
params.setAttr("do_zfit", "int", 0)
params.setAttr("cutoff", "float", 0.0)
params.setAttr("max_z", "float", 0.5)
params.setAttr("min_z", "float", -0.5)
params.setAttr("z_value", "float", 0.0)
params.setAttr("z_step", "float", 1.0)
params.setAttr("wx_wo", "float", 1.0)
params.setAttr("wx_c", "float", 1.0)
params.setAttr("wx_d", "float", 1.0)
params.setAttr("wxA", "float", 0.0)
params.setAttr("wxB", "float", 0.0)
params.setAttr("wxC", "float", 0.0)
params.setAttr("wxD", "float", 0.0)
params.setAttr("wy_wo", "float", 1.0)
params.setAttr("wy_c", "float", 1.0)
params.setAttr("wy_d", "float", 1.0)
params.setAttr("wyA", "float", 0.0)
params.setAttr("wyB", "float", 0.0)
params.setAttr("wyC", "float", 0.0)
params.setAttr("wyD", "float", 0.0)
params.toXMLFile("daostorm.xml")
def test_get_attr_3():
"""
Test getting parameters.
"""
# Load some parameters.
original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml")
p1 = params.ParametersDAO().initFromFile(original, warnings=True)
v1 = p1.getAttr("start_frame")
v1 = p1.getAttr("x_start", 1)
def test_get_help_1():
"""
Test getting help.
"""
# Load some parameters.
original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml")
p1 = params.ParametersDAO().initFromFile(original, warnings=True)
v1 = p1.helpAttr("max_frame")
v1 = p1.helpAttr("convert_to")
def test_pretty_print_1():
# This just tests that it doesn't fail. It does not check the
# formatting of the output file.
original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml")
output = storm_analysis.getPathOutputTest("test_pp1.xml")
# Load parameters.
p1 = params.ParametersDAO().initFromFile(original, warnings=True)
# Convert back to XML.
p1.toXMLFile(output, pretty=True)
def test_change_attr_2():
"""
Test specifying a node type that doesn't exist.
"""
p1 = params.ParametersDAO()
try:
v1 = p1.changeAttr("find_max_radius", 1, node_type="foo")
except params.ParametersException:
return
assert False
def test_change_attr_1():
"""
Test not specifying the node type.
"""
p1 = params.ParametersDAO()
try:
v1 = p1.changeAttr("find_max_radius", 1)
except params.ParametersException:
return
assert False
def test_get_attr_2():
"""
Test no such parameter with default value.
"""
# Load some parameters.
original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml")
p1 = params.ParametersDAO().initFromFile(original, warnings=True)
try:
v1 = p1.getAttr("foo", default="bar")
except params.ParametersException:
return
assert False
def test_get_help_2():
"""
Test getting help with a parameter that does not exist.
"""
# Load some parameters.
original = storm_analysis.getData("test/data/test_3d_2d_fixed.xml")
p1 = params.ParametersDAO().initFromFile(original, warnings=True)
try:
v1 = p1.helpAttr("foo")
except params.ParametersException:
return
assert False
def test_mspb_3():
"""
Test (single) PSF measurement with drift.
"""
# Make test movie.
im_max = 1000.0
n_pts = 10
x = 7.0
y = 11.0
drift_xy = numpy.random.uniform(size=(n_pts, 2))
psf_movie = storm_analysis.getPathOutputTest("psf_movie.tif")
with tifffile.TiffWriter(psf_movie) as tf:
for i in range(n_pts):
image = dg.drawGaussiansXY((20, 20),
numpy.array([x + drift_xy[i][0]]),
numpy.array([y + drift_xy[i][1]]))
image = image * im_max
tf.save(image.astype(numpy.float32))
# Parameters.
p = params.ParametersDAO()
p.changeAttr("camera_gain", 1.0)
p.changeAttr("camera_offset", 0.0)
# Frame reader.
frdr = analysisIO.FrameReaderStd(movie_file=psf_movie, parameters=p)
z_index = numpy.zeros(n_pts).astype(numpy.int) - 1
z_index[0] = 0
[psf0, samples] = mPSFUtils.measureSinglePSFBeads(frdr,
z_index,
6,
x + drift_xy[0][0],
y + drift_xy[0][1],
zoom=2)
for i in range(1, n_pts):
z_index = numpy.zeros(n_pts).astype(numpy.int) - 1
z_index[i] = 0
[psf, samples] = mPSFUtils.measureSinglePSFBeads(frdr,
z_index,
6,
x,
y,
drift_xy=drift_xy,
zoom=2)
assert (numpy.max(numpy.abs(psf0 - psf) / numpy.max(psf)) < 0.05)
def test_fitz_c_4():
"""
Test that tracks with wx, wy values that are not near the calibration
curve are assigned z values less than z minimum.
Their category remains unchanged as this is done in a separate step.
"""
# Load 3D parameters.
settings = storm_analysis.getData("test/data/test_3d_3d.xml")
parameters = params.ParametersDAO().initFromFile(settings)
[wx_params, wy_params] = parameters.getWidthParams()
[min_z, max_z] = parameters.getZRange()
pixel_size = parameters.getAttr("pixel_size")
# Calculate widths.
z_vals = numpy.arange(-250.0, 251.0, 50)
[sx, sy] = fitzC.calcSxSy(wx_params, wy_params, z_vals)
# Create HDF5 file with these widths.
track_length = numpy.ones(sx.size)
track_length[:2] = 2
tracks = {
"category": numpy.ones(sx.size, dtype=numpy.int32),
"track_length": track_length,
"x": numpy.zeros(sx.size),
"xsigma": track_length * (sx / pixel_size + numpy.ones(sx.size)),
"ysigma": track_length * (sy / pixel_size + numpy.ones(sx.size))
}
h5_name = storm_analysis.getPathOutputTest("test_sa_hdf5.hdf5")
storm_analysis.removeFile(h5_name)
with saH5Py.SAH5Py(h5_name, is_existing=False) as h5:
h5.setMovieInformation(256, 256, 10, "XYZZY")
h5.setPixelSize(pixel_size)
h5.addTracks(tracks)
# Calculate Z values.
fitzC.fitzTracks(h5_name, 1.5, wx_params, wy_params, min_z, max_z, 1.0e-3)
# Check Z values.
with saH5Py.SAH5Py(h5_name) as h5:
for tracks in h5.tracksIterator():
assert (numpy.allclose(tracks["z"],
min_z * numpy.ones(sx.size) - 1.0e-3))
assert (numpy.allclose(tracks["category"], numpy.ones(sx.size)))
def test_mspb_2():
"""
Test (single) PSF measurement, no drift, recentering.
The maximum relative difference is typically on the order of 2%.
"""
# Make test movie.
im_max = 1000.0
x = 7.0 + numpy.random.uniform(size=10)
y = 11.0 + numpy.random.uniform(size=10)
psf_movie = storm_analysis.getPathOutputTest("psf_movie.tif")
with tifffile.TiffWriter(psf_movie) as tf:
for i in range(x.size):
image = dg.drawGaussiansXY((20, 20), numpy.array([x[i]]),
numpy.array([y[i]]))
image = image * im_max
tf.save(image.astype(numpy.float32))
# Parameters.
p = params.ParametersDAO()
p.changeAttr("camera_gain", 1.0)
p.changeAttr("camera_offset", 0.0)
# Frame reader.
frdr = analysisIO.FrameReaderStd(movie_file=psf_movie, parameters=p)
z_index = numpy.zeros(x.size).astype(numpy.int) - 1
z_index[0] = 0
[psf0, samples] = mPSFUtils.measureSinglePSFBeads(frdr,
z_index,
6,
x[0],
y[0],
zoom=2)
for i in range(1, x.size):
z_index = numpy.zeros(x.size).astype(numpy.int) - 1
z_index[i] = 0
[psf, samples] = mPSFUtils.measureSinglePSFBeads(frdr,
z_index,
6,
x[i],
y[i],
zoom=2)
assert (numpy.max(numpy.abs(psf0 - psf) / numpy.max(psf)) < 0.05)
def test_std_analysis_1():
"""
Test zCheck.
"""
# Load 3D parameters.
settings = storm_analysis.getData("test/data/test_3d_3d.xml")
parameters = params.ParametersDAO().initFromFile(settings)
[min_z, max_z] = parameters.getZRange()
assert (abs(min_z + 0.5) < 1.0e-6)
assert (abs(max_z - 0.5) < 1.0e-6)
# Create HDF5 file with localizations and tracks.
zvals = numpy.arange(-1.0, 1.05, 0.2)
peaks = {
"category": numpy.ones(zvals.size, dtype=numpy.int32),
"x": numpy.zeros(zvals.size),
"z": zvals
}
h5_name = storm_analysis.getPathOutputTest("test_sa_hdf5.hdf5")
storm_analysis.removeFile(h5_name)
with saH5Py.SAH5Py(h5_name, is_existing=False) as h5:
h5.setMovieInformation(256, 256, 10, "XYZZY")
h5.addLocalizations(peaks, 1)
h5.addTracks(peaks)
# Run z check on the file.
stdAnalysis.zCheck(h5_name, parameters)
# Check track and localization categories.
category = numpy.ones(zvals.size, dtype=numpy.int32)
z_mask = (zvals < min_z) | (zvals > max_z)
category[z_mask] = 9
with saH5Py.SAH5Py(h5_name) as h5:
for fnum, locs in h5.localizationsIterator(fields=["category"]):
assert (numpy.allclose(locs["category"], category))
for tracks in h5.tracksIterator(fields=["category"]):
assert (numpy.allclose(tracks["category"], category))
def test_fitz_c_2():
"""
Test that localizations with wx, wy values that are not near
the calibration curve are assigned z values less than z minimum.
"""
# Load 3D parameters.
settings = storm_analysis.getData("test/data/test_3d_3d.xml")
parameters = params.ParametersDAO().initFromFile(settings)
[wx_params, wy_params] = parameters.getWidthParams()
[min_z, max_z] = parameters.getZRange()
pixel_size = parameters.getAttr("pixel_size")
# Calculate widths.
z_vals = numpy.arange(-250.0, 251.0, 100)
[sx, sy] = fitzC.calcSxSy(wx_params, wy_params, z_vals)
# Create HDF5 file with these widths.
peaks = {
"x": numpy.zeros(sx.size),
"xsigma": sx / pixel_size + numpy.ones(sx.size),
"ysigma": sy / pixel_size + numpy.ones(sx.size)
}
h5_name = storm_analysis.getPathOutputTest("test_sa_hdf5.hdf5")
storm_analysis.removeFile(h5_name)
with saH5Py.SAH5Py(h5_name, is_existing=False) as h5:
h5.setMovieInformation(256, 256, 10, "XYZZY")
h5.setPixelSize(pixel_size)
h5.addLocalizations(peaks, 1)
# Calculate Z values.
fitzC.fitzRaw(h5_name, 1.5, wx_params, wy_params, min_z, max_z, 1.0e-3)
# Check Z values.
with saH5Py.SAH5Py(h5_name) as h5:
locs = h5.getLocalizationsInFrame(1)
assert (numpy.allclose(locs["z"],
min_z * numpy.ones(sx.size) - 1.0e-3))
def test_mspb_1():
"""
Test (single) PSF measurement, no drift.
"""
# Make test movie.
x = 7.2
y = 9.8
psf_movie = storm_analysis.getPathOutputTest("psf_movie.tif")
image = 1000.0 * dg.drawGaussiansXY(
(20, 20), numpy.array([x]), numpy.array([y]))
with tifffile.TiffWriter(psf_movie) as tf:
for i in range(6):
tf.save(image.astype(numpy.float32))
# Parameters.
p = params.ParametersDAO()
p.changeAttr("camera_gain", 1.0)
p.changeAttr("camera_offset", 0.0)
# Frame reader.
frdr = analysisIO.FrameReaderStd(movie_file=psf_movie, parameters=p)
z_index = numpy.array([0, 1, 2, 2, -1, -1])
[psf, samples] = mPSFUtils.measureSinglePSFBeads(frdr,
z_index,
6,
x,
y,
zoom=2)
assert (numpy.allclose(samples, numpy.array([1, 1, 2])))
for i in range(1, psf.shape[0]):
assert (numpy.allclose(psf[0, :, :], psf[i, :, :] / samples[i]))
if False:
with tifffile.TiffWriter("psf.tif") as tf:
for i in range(psf.shape[0]):
tf.save(psf[i, :, :].astype(numpy.float32))
def test_3ddao_scmos_cal():
"""
Test that scmos calibration data is initialized to 0.0.
"""
settings = storm_analysis.getData("test/data/test_3d_2d_fixed.xml")
parameters = params.ParametersDAO().initFromFile(settings)
# Create analysis object and reach deep into it..
find_fit = findPeaks.initFindAndFit(parameters)
fitter = find_fit.peak_fitter
mfitter = fitter.mfitter
# Initialize with an image.
image = numpy.ones((100, 100))
fitter.newImage(image)
# Verify that the image is still all ones.
resp = mfitter.getResidual()
assert (numpy.max(resp - 1.0) < 1.0e-6)
# Cleanup.
fitter.cleanUp()
def analyze(movie_name, mlist_name, settings_name):
# Load parameters.
parameters = params.ParametersDAO().initFromFile(settings_name)
# Check for possibly v1.0 parameters.
if not parameters.hasAttr("background_sigma"):
raise Exception("Parameter 'background_sigma' is missing. Version 1.0 parameters?")
# Create finding and fitting object.
finder = find_peaks.initFindAndFit(parameters)
# Create object for reading (non sCMOS) camera frames.
movie_ext = os.path.splitext(movie_name)[1]
if movie_ext == '.nd2':
frame_reader = FrameReaderStdNd2(movie_file = movie_name,
parameters = parameters)
else:
frame_reader = analysisIO.FrameReaderStd(movie_file = movie_name,
parameters = parameters)
# Create movie reader (uses frame_reader).
movie_reader = analysisIO.MovieReader(frame_reader = frame_reader,
parameters = parameters)
# Create localization file writer.
data_writer = analysisIO.DataWriterHDF5(data_file = mlist_name,
parameters = parameters,
sa_type = '3D-DAOSTORM')
# Run the analysis.
std_analysis.standardAnalysis(finder,
movie_reader,
data_writer,
parameters)
if (__name__ == "__main__"):
import argparse
import storm_analysis.sa_library.parameters as params
parser = argparse.ArgumentParser(description = 'Z fitting given Wx, Wy calibration curves.')
parser.add_argument('--bin', dest='mlist', type=str, required=True,
help = "The name of the localizations file.")
parser.add_argument('--xml', dest='settings', type=str, required=True,
help = "The name of the settings xml file.")
args = parser.parse_args()
parameters = params.ParametersDAO().initFromFile(args.settings)
[wx_params, wy_params] = parameters.getWidthParams()
[min_z, max_z] = parameters.getZRange()
fitz(args.mlist,
parameters.getAttr("cutoff"),
wx_params,
wy_params,
min_z,
max_z,
parameters.getAttr("z_step", 0.001))
def analyze(movie_name, mlist_name, settings_name):
parameters = params.ParametersDAO().initFromFile(settings_name)
finder = find_peaks.initFindAndFit(parameters)
std_analysis.standardAnalysis(finder, movie_name, mlist_name, parameters)
def testingParameters():
"""
Create a 3D-DAOSTORM parameters object.
"""
params = parameters.ParametersDAO()
params.setAttr("max_frame", "int", -1)
params.setAttr("start_frame", "int", -1)
params.setAttr("background_sigma", "float", 8.0)
params.setAttr("camera_gain", "float", settings.camera_gain)
params.setAttr("camera_offset", "float", settings.camera_offset)
params.setAttr("find_max_radius", "int", 5)
params.setAttr("foreground_sigma", "float", 1.0)
params.setAttr("iterations", "int", settings.iterations)
params.setAttr("model", "string", settings.model)
params.setAttr("pixel_size", "float", settings.pixel_size)
params.setAttr("roi_size", "int", 9)
params.setAttr("sigma", "float", 1.5)
params.setAttr("threshold", "float", 6.0)
# Don't do tracking.
params.setAttr("descriptor", "string", "1")
params.setAttr("radius", "float", "0")
# Don't do drift-correction.
params.setAttr("d_scale", "int", 2)
params.setAttr("drift_correction", "int", 0)
params.setAttr("frame_step", "int", 500)
params.setAttr("z_correction", "int", 0)
# Z fitting.
#
# These are nonsense values. We test either '2D' or '3D' mode
# and check how will we do at fitting the localization widths.
#
params.setAttr("do_zfit", "int", 0)
params.setAttr("cutoff", "float", 0.0)
params.setAttr("max_z", "float", 0.5)
params.setAttr("min_z", "float", -0.5)
params.setAttr("z_value", "float", 0.0)
params.setAttr("z_step", "float", 1.0)
params.setAttr("wx_wo", "float", 300.0)
params.setAttr("wx_c", "float", 150.0)
params.setAttr("wx_d", "float", 400.0)
params.setAttr("wxA", "float", 0.0)
params.setAttr("wxB", "float", 0.0)
params.setAttr("wxC", "float", 0.0)
params.setAttr("wxD", "float", 0.0)
params.setAttr("wy_wo", "float", 300.0)
params.setAttr("wy_c", "float", -150.0)
params.setAttr("wy_d", "float", 400.0)
params.setAttr("wyA", "float", 0.0)
params.setAttr("wyB", "float", 0.0)
params.setAttr("wyC", "float", 0.0)
params.setAttr("wyD", "float", 0.0)
# File conversion testing.
#params.setAttr("convert_to", "string", ".bin,.txt")
#params.setAttr("convert_to", "string", ".bin")
#params.setAttr("convert_to", "string", ".txt")
# 'peak_locations' testing.
if hasattr(settings, "peak_locations") and (settings.peak_locations is not None):
params.setAttr("peak_locations", "filename", settings.peak_locations)
return params
