def test_write_read_xml_calibrate(temp_file, region1, region2, peak,
calfactor1, calfactor2, calfactor3):
"""
Write/Read fit and calibrate afterwards
Fit should move with spectrum to new calibration
"""
test_write_read_xml(temp_file, region1, region2, peak, calfactor1,
calfactor2)
fit = list(spectra.Get("0").dict.items())[0][1]
markers_initial = get_markers(fit)
integral_initial = fit.ExtractIntegralParams()[0][0]
spectra.ApplyCalibration("0", [0, calfactor3])
fit = list(spectra.Get("0").dict.items())[0][1]
markers_final = get_markers(fit)
integral_final = fit.ExtractIntegralParams()[0][0]
assert isclose(markers_initial[1],
markers_final[1] / calfactor3 * calfactor2)
assert isclose(markers_initial[3],
markers_final[3] / calfactor3 * calfactor2)
assert isclose(markers_initial[5],
markers_final[5] / calfactor3 * calfactor2)
for key in ["pos", "width_cal"]:
assert isclose(
integral_initial[key].nominal_value,
integral_final[key].nominal_value / calfactor3 * calfactor2)
def test_reimport_calibrate_write_read(temp_file, region1, region2, peak,
calfactor1, calfactor2, calfactor3):
"""
Write/Read fit and change calibration in between
Fit should appear at the new calibrated position
"""
test_store_fit(region1, region2, peak, calfactor1, calfactor2)
spectra.ActivateFit(None)
fit = list(spectra.Get("0").dict.items())[0][1]
markers_initial = get_markers(fit)
integral_initial = fit.ExtractIntegralParams()[0][0]
fitxml.WriteXML(spectra.Get("0").ID, temp_file)
spectra.Get("0").Clear()
spectra.ApplyCalibration(0, [0, calfactor3])
fitxml.ReadXML(spectra.Get("0").ID, temp_file)
fit = list(spectra.Get("0").dict.items())[0][1]
markers_final = get_markers(fit)
integral_final = fit.ExtractIntegralParams()[0][0]
assert isclose(markers_initial[1],
markers_final[1] / calfactor3 * calfactor2)
assert isclose(markers_initial[3],
markers_final[3] / calfactor3 * calfactor2)
assert isclose(markers_initial[5],
markers_final[5] / calfactor3 * calfactor2)
for key in ["pos", "width_cal"]:
assert isclose(
integral_initial[key].nominal_value,
integral_final[key].nominal_value / calfactor3 * calfactor2)
def markers_consistent(calfactor=1., region1=None, region2=None, fit=None):
markers = get_markers(fit)
assert isclose(markers[0], markers[1] / calfactor)
assert isclose(markers[2], markers[3] / calfactor)
assert isclose(markers[4], markers[5] / calfactor)
if region1:
assert isclose(markers[1], region1)
if region2:
assert isclose(markers[3], region2)
def test_change_calibration_while_stored_activate(region1, region2, peak,
calfactor1, calfactor2,
calfactor3):
"""
Reactivate fit after calibration has changed
Active markers should appear at the same position as fit
"""
test_execute_reactivated_fit(region1, region2, peak, calfactor1,
calfactor2)
spectra.ActivateFit(None)
spectra.ClearFit()
spectra.ApplyCalibration("0", [0, calfactor3])
fit = list(spectra.Get("0").dict.items())[0][1]
markers_initial = get_markers(fit)
spectra.ActivateFit("0")
markers_final = get_markers()
assert isclose(markers_initial[1], markers_final[1])
assert isclose(markers_initial[3], markers_final[3])
assert isclose(markers_initial[5], markers_final[5])
def test_root_fit_volume_with_binning(region1, region2, peak, expected_volume,
spectrum):
# Mock parser so RootGet can be used
# args = mock.Mock()
args = type("Test", (object, ), {})
args.pattern = [os.path.join("tests", "share", "binning.root", spectrum)]
args.replace = False
args.load_cal = False
args.invisible = False
hdtv.plugins.rootInterface.r.RootGet(args)
session.SetMarker("region", region1)
session.SetMarker("region", region2)
session.SetMarker("peak", peak)
session.ExecuteFit()
fit = session.workFit
fit_volume = fit.ExtractParams()[0][0]["vol"].nominal_value
integral_volume = fit.ExtractIntegralParams()[0][0]["vol"].nominal_value
assert isclose(integral_volume, expected_volume, abs_tol=10)
assert isclose(fit_volume, expected_volume, abs_tol=200)
hdtv.plugins.rootInterface.r.RootClose(None)
def test_execute_reactivated_calibrated_fit(region1, region2, peak, calfactor1,
calfactor2, calfactor3):
"""
Execute reactivated fit
New fit should be at the same position as the stored fit
"""
test_execute_reactivated_fit(region1, region2, peak, calfactor1,
calfactor2)
spectra.ActivateFit(None)
spectra.ClearFit()
spectra.ApplyCalibration("0", [0, calfactor3])
spectra.ActivateFit("0")
spectra.ExecuteFit()
fit = list(spectra.Get("0").dict.items())[0][1]
markers_work = get_markers(fit)
markers_stored = get_markers()
assert isclose(markers_stored[1], markers_work[1], rel_tol=1e-7)
assert isclose(markers_stored[3], markers_work[3], rel_tol=1e-7)
assert isclose(markers_stored[5], markers_work[5], rel_tol=1e-7)
def test_change_calibration_while_stored(region1, region2, peak, calfactor1,
calfactor2, calfactor3):
"""
Change calibration after fit is stored
Stored fit should move with spectrum to new position
"""
test_execute_reactivated_fit(region1, region2, peak, calfactor1,
calfactor2)
spectra.ActivateFit(None)
spectra.ClearFit()
fit = list(spectra.Get("0").dict.items())[0][1]
markers_initial = get_markers(fit)
spectra.ApplyCalibration("0", [0, calfactor3])
markers_final = get_markers(fit)
assert isclose(markers_initial[1],
markers_final[1] / calfactor3 * calfactor2)
assert isclose(markers_initial[3],
markers_final[3] / calfactor3 * calfactor2)
assert isclose(markers_initial[5],
markers_final[5] / calfactor3 * calfactor2)
def test_root_to_root_conversion_for_unconventional_binning():
# Mock parser so RootGet can be used
# args = mock.Mock()
args = type("Test", (object, ), {})
args.replace = False
args.load_cal = False
args.invisible = False
args.pattern = [os.path.join("tests", "share", "binning.root", "h")]
hdtv.plugins.rootInterface.r.RootGet(args)
args.pattern = [os.path.join("tests", "share", "binning.root", "h2")]
hdtv.plugins.rootInterface.r.RootGet(args)
assert not get_spec(0).cal
assert isclose(get_spec(1).cal.GetCoeffs()[1], 0.5)
def test_mfile_fit_volume_with_binning(region1, region2, peak, expected_volume,
calfactor, temp_file):
spectra.Clear()
bins = linspace(0.5, NBINS + 0.5, int(NBINS / calfactor))
spectrum = 1. / calfactor * BG_PER_BIN * ones(int(NBINS / calfactor))
spectrum = spectrum + calfactor * PEAK_VOLUME * norm.pdf(
bins, loc=0.5 * NBINS, scale=PEAK_WIDTH)
savetxt(temp_file, spectrum)
spec_interface.LoadSpectra(temp_file)
spectra.ApplyCalibration("0", [0, calfactor])
spectra.SetMarker("region", region1)
spectra.SetMarker("region", region2)
spectra.SetMarker("peak", peak)
spectra.ExecuteFit()
fit = spectra.workFit
fit_volume = fit.ExtractParams()[0][0]["vol"].nominal_value
integral_volume = fit.ExtractIntegralParams()[0][0]["vol"].nominal_value
assert isclose(integral_volume, expected_volume, abs_tol=sqrt(PEAK_VOLUME))
assert isclose(fit_volume, expected_volume, abs_tol=sqrt(PEAK_VOLUME))
def test_backgroundRegions(
model,
nparams,
step,
nregions,
settings,
errormessage,
bgparams,
bg_volume,
temp_file,
test_spectrum,
):
spec_interface.LoadSpectra(test_spectrum.filename)
command = ["fit function background activate " + model]
if settings != "":
command.append(settings)
for i in range(nregions):
command.append(
"fit marker background set %f"
% ((step + test_spectrum.bg_regions[i][0]) * test_spectrum.nbins_per_step)
)
command.append(
"fit marker background set %f"
% ((step + test_spectrum.bg_regions[i][1]) * test_spectrum.nbins_per_step)
)
command.append(
"fit marker region set %f"
% (
(step + 0.5) * test_spectrum.nbins_per_step
- 3.0 * test_spectrum.peak_width * test_spectrum.nbins_per_step
)
)
command.append(
"fit marker region set %f"
% (
(step + 0.5) * test_spectrum.nbins_per_step
+ 3.0 * test_spectrum.peak_width * test_spectrum.nbins_per_step
)
)
command.append(
"fit marker peak set %f" % ((step + 0.5) * test_spectrum.nbins_per_step)
)
command.append("fit execute")
command.append("fit store")
for i in range(nregions):
command.append("fit marker background delete %i" % (i))
command.append("fit marker region delete 0")
command.append("fit marker peak delete 0")
f, ferr = hdtvcmd(*command)
if WRITE_BATCHFILE:
batchfile = os.path.join(
os.path.curdir,
"test",
"share",
model + "_" + str(nparams) + "_" + str(step) + "_background.hdtv",
)
bfile = open(batchfile, "w")
bfile.write("spectrum get " + test_spectrum.filename + "\n")
for c in command:
bfile.write(c + "\n")
bfile.close()
if errormessage != "":
hdtvcmd("fit delete 0", "spectrum delete 0")
assert errormessage in ferr
else:
assert ferr == ""
fitxml.WriteXML(spectra.Get("0").ID, temp_file)
fitxml.ReadXML(spectra.Get("0").ID, temp_file, refit=True, interactive=False)
hdtvcmd("fit delete 0", "spectrum delete 0")
# Parse xml file manually and check correct output
tree = ET.parse(temp_file)
root = tree.getroot()
# Check the number of fits
fits = root.findall("fit")
assert len(fits) == 1
# Check the number and positions of background markers
bgMarkers = fits[0].findall("bgMarker")
assert len(bgMarkers) == nregions
for i in range(len(bgMarkers)):
assert isclose(
float(bgMarkers[i].find("begin").find("cal").text),
(step + test_spectrum.bg_regions[i][0]) * test_spectrum.nbins_per_step,
abs_tol=BG_MARKER_TOLERANCE,
)
assert isclose(
float(bgMarkers[i].find("end").find("cal").text),
(step + test_spectrum.bg_regions[i][1]) * test_spectrum.nbins_per_step,
abs_tol=BG_MARKER_TOLERANCE,
)
# Check the number (and values) of background parameters
background = fits[0].find("background")
assert background.get("backgroundModel") == model
assert int(background.get("nparams")) == nparams
# Check the background parameters
if len(bgparams) > 0:
params = background.findall("param")
for i in range(len(params)):
if i < len(bgparams):
assert isclose(
float(params[i].find("value").text),
bgparams[i],
abs_tol=N_SIGMA * float(params[i].find("error").text),
)
# Check the fit result
# All results will be compared
assert isclose(
float(fits[0].find("peak").find("cal").find("vol").find("value").text),
test_spectrum.peak_volume,
abs_tol=N_SIGMA
* float(fits[0].find("peak").find("cal").find("vol").find("error").text),
)
assert isclose(
float(fits[0].find("peak").find("cal").find("width").find("value").text),
SIGMA_TO_FWHM * test_spectrum.peak_width * test_spectrum.nbins_per_step,
abs_tol=N_SIGMA
* float(fits[0].find("peak").find("cal").find("width").find("error").text),
)
# Check the integration result
integrals = fits[0].findall("integral")
assert len(integrals) == 3
assert integrals[0].get("integraltype") == "tot"
assert integrals[1].get("integraltype") == "bg"
assert integrals[2].get("integraltype") == "sub"
# Peak volume
assert isclose(
float(integrals[2].find("uncal").find("vol").find("value").text),
test_spectrum.peak_volume,
abs_tol=N_SIGMA
* float(integrals[2].find("uncal").find("vol").find("error").text),
)
# Background volume
if bg_volume > 0.0:
assert isclose(
float(integrals[1].find("uncal").find("vol").find("value").text),
bg_volume,
abs_tol=sqrt(bg_volume),
)
else:
assert isclose(
float(integrals[1].find("uncal").find("vol").find("value").text),
test_spectrum.bg_per_bin
* 6.0
* test_spectrum.peak_width
* test_spectrum.nbins_per_step,
abs_tol=N_SIGMA
* sqrt(
test_spectrum.bg_per_bin
* 6.0
* test_spectrum.peak_width
* test_spectrum.nbins_per_step
),
)
def test_calbin(temp_file, test_spectrum):
command = ["spectrum get " + test_spectrum.filename]
step = 2 # Use the third spectrum which has a constant background and Poissonian fluctuations
# Fit the peak in step 2
command.append("fit marker background set %f" %
((step + test_spectrum.bg_regions[0][0]) *
test_spectrum.nbins_per_step))
command.append("fit marker background set %f" %
((step + test_spectrum.bg_regions[0][1]) *
test_spectrum.nbins_per_step))
command.append("fit marker background set %f" %
((step + test_spectrum.bg_regions[1][0]) *
test_spectrum.nbins_per_step))
command.append("fit marker background set %f" %
((step + test_spectrum.bg_regions[1][1]) *
test_spectrum.nbins_per_step))
command.append(
"fit marker region set %f" %
((step + 0.5) * test_spectrum.nbins_per_step -
3.0 * test_spectrum.peak_width * test_spectrum.nbins_per_step))
command.append(
"fit marker region set %f" %
((step + 0.5) * test_spectrum.nbins_per_step +
3.0 * test_spectrum.peak_width * test_spectrum.nbins_per_step))
command.append("fit marker peak set %f" %
((step + 0.5) * test_spectrum.nbins_per_step))
command.append("fit execute")
command.append("fit store")
f, ferr = hdtvcmd(*command)
if WRITE_BATCHFILE:
batchfile = os.path.join(os.path.curdir, "test", "share",
"calbin.hdtv")
with open(batchfile, "w") as bfile:
for c in command:
bfile.write(c + "\n")
assert ferr == ""
# Write the fit result to a temporary XML file
fitxml.WriteXML(spectra.Get("0").ID, temp_file)
fitxml.ReadXML(spectra.Get("0").ID,
temp_file,
refit=True,
interactive=False)
# Parse XML file manually
tree = ET.parse(temp_file)
root = tree.getroot()
# Check the number of fits
fits = root.findall("fit")
assert len(fits) == 1
# Read out the main fitted peak properties (position, volume, width) and their uncertainties
pos_value_init = float(
fits[0].find("peak").find("cal").find("pos").find("value").text)
pos_error_init = abs(
float(fits[0].find("peak").find("cal").find("pos").find("error").text))
vol_value_init = float(
fits[0].find("peak").find("cal").find("vol").find("value").text)
vol_error_init = abs(
float(fits[0].find("peak").find("cal").find("vol").find("error").text))
width_value_init = float(
fits[0].find("peak").find("cal").find("width").find("value").text)
width_error_init = abs(
float(
fits[0].find("peak").find("cal").find("width").find("error").text))
# Calbin the spectrum with standard settings, read in the fitted value again and check whether they have changed
command = ["spectrum calbin 0 -s 1"]
command.append("fit execute")
command.append("fit store")
f, ferr = hdtvcmd(*command)
assert ferr == ""
if WRITE_BATCHFILE:
batchfile = os.path.join(os.path.curdir, "test", "share",
"calbin.hdtv")
with open(batchfile, "a") as bfile:
for c in command:
bfile.write(c + "\n")
assert ferr == ""
fitxml.WriteXML(spectra.Get("0").ID, temp_file)
fitxml.ReadXML(spectra.Get("0").ID,
temp_file,
refit=False,
interactive=False)
tree = ET.parse(temp_file)
root = tree.getroot()
fits = root.findall("fit")
# It is a little bit unsatisfactory to accumulate the fits multiple times in temp_file, but I found no way to erase the content of temp_file
# open(temp_file, 'w').close() wouldn't work
assert len(fits) == 3
pos_value_1 = float(
fits[2].find("peak").find("cal").find("pos").find("value").text)
pos_error_1 = abs(
float(fits[2].find("peak").find("cal").find("pos").find("error").text))
vol_value_1 = float(
fits[2].find("peak").find("cal").find("vol").find("value").text)
vol_error_1 = abs(
float(fits[2].find("peak").find("cal").find("vol").find("error").text))
width_value_1 = float(
fits[2].find("peak").find("cal").find("width").find("value").text)
width_error_1 = abs(
float(
fits[2].find("peak").find("cal").find("width").find("error").text))
# For the fit of the position, allow it to deviate by N_SIGMA times the combined standard deviations of the fitted positions PLUS the width of a single bin.
assert isclose(
pos_value_init - pos_value_1,
0.0,
abs_tol=N_SIGMA *
sqrt(pos_error_init * pos_error_init + pos_error_1 * pos_error_1) +
1.0,
)
assert isclose(
vol_value_init - vol_value_1,
0.0,
abs_tol=N_SIGMA *
sqrt(vol_error_init * vol_error_init + vol_error_1 * vol_error_1),
)
assert isclose(
width_value_init - width_value_1,
0.0,
abs_tol=N_SIGMA * sqrt(width_error_init * width_error_init +
width_error_1 * width_error_1),
)
# Calbin the spectrum with a factor of 2, read in the fitted value again and check whether they have changed
command = ["spectrum calbin 0 -b 2 -s 0"]
command.append("fit execute")
command.append("fit store")
f, ferr = hdtvcmd(*command)
assert ferr == ""
if WRITE_BATCHFILE:
batchfile = os.path.join(os.path.curdir, "test", "share",
"calbin.hdtv")
with open(batchfile, "a") as bfile:
for c in command:
bfile.write(c + "\n")
assert ferr == ""
fitxml.WriteXML(spectra.Get("0").ID, temp_file)
fitxml.ReadXML(spectra.Get("0").ID,
temp_file,
refit=False,
interactive=False)
tree = ET.parse(temp_file)
root = tree.getroot()
fits = root.findall("fit")
assert len(fits) == 7
pos_value_2 = float(
fits[6].find("peak").find("cal").find("pos").find("value").text)
pos_error_2 = abs(
float(fits[6].find("peak").find("cal").find("pos").find("error").text))
vol_value_2 = float(
fits[6].find("peak").find("cal").find("vol").find("value").text)
vol_error_2 = abs(
float(fits[6].find("peak").find("cal").find("vol").find("error").text))
width_value_2 = float(
fits[6].find("peak").find("cal").find("width").find("value").text)
width_error_2 = abs(
float(
fits[6].find("peak").find("cal").find("width").find("error").text))
assert isclose(
pos_value_init - pos_value_2,
0.0,
abs_tol=N_SIGMA *
sqrt(pos_error_init * pos_error_init + pos_error_2 * pos_error_2) +
2.0,
)
assert isclose(
vol_value_init - vol_value_2,
0.0,
abs_tol=N_SIGMA *
sqrt(vol_error_init * vol_error_init + vol_error_2 * vol_error_2),
)
assert isclose(
width_value_init - width_value_2,
0.0,
abs_tol=N_SIGMA * sqrt(width_error_init * width_error_init +
width_error_2 * width_error_2),
)
assert isclose(pos_error_init, pos_error_2, rel_tol=0.2)
assert isclose(vol_error_init, vol_error_2, rel_tol=0.2)
assert isclose(pos_error_init, pos_error_2, rel_tol=0.2)
