def determine_ref_background(obj, no_bkg=False):
"""
This function takes in a collection of pixels that have been selected as
the reflectometer background. The pixels are summed into a single spectrum
and then scaled by the total number of pixels present in the selection.
@param obj: Object containing reflectometer background information
@type obj: C{SOM.SOM}
@param no_bkg: (OPTIONAL) Flag which determines if the background will be
calculated
@type no_bkg: C{boolean}
@return: A length object containing a summed background spectrum scaled by
the total number of background pixels
@rtype: C{SOM.SOM}
"""
import dr_lib
import common_lib
import hlr_utils
# If user does not desire background subtraction or incoming SOM is None,
# return None
if no_bkg or obj is None:
return None
# set up for working through data
o_descr = hlr_utils.get_descr(obj)
if o_descr != "SOM":
raise RuntimeError("Must provide a SOM to the function.")
# Go on
else:
pass
# Combine all background spectra into one
obj1 = dr_lib.sum_all_spectra(obj)
# Determine scaling ratio
ratio = (1.0 / float(len(obj)), 0.0)
# Scale background spectrum by ratio
return common_lib.mult_ncerr(obj1, ratio)
def determine_ref_background(obj, no_bkg=False):
"""
This function takes in a collection of pixels that have been selected as
the reflectometer background. The pixels are summed into a single spectrum
and then scaled by the total number of pixels present in the selection.
@param obj: Object containing reflectometer background information
@type obj: C{SOM.SOM}
@param no_bkg: (OPTIONAL) Flag which determines if the background will be
calculated
@type no_bkg: C{boolean}
@return: A length object containing a summed background spectrum scaled by
the total number of background pixels
@rtype: C{SOM.SOM}
"""
import dr_lib
import common_lib
import hlr_utils
# If user does not desire background subtraction or incoming SOM is None,
# return None
if no_bkg or obj is None:
return None
# set up for working through data
o_descr = hlr_utils.get_descr(obj)
if o_descr != "SOM":
raise RuntimeError("Must provide a SOM to the function.")
# Go on
else:
pass
# Combine all background spectra into one
obj1 = dr_lib.sum_all_spectra(obj)
# Determine scaling ratio
ratio = (1.0 / float(len(obj)), 0.0)
# Scale background spectrum by ratio
return common_lib.mult_ncerr(obj1, ratio)
def run(config, tim=None):
"""
This method is where the data reduction process gets done.
@param config: Object containing the data reduction configuration
information.
@type config: L{hlr_utils.Configure}
@param tim: (OPTIONAL) Object that will allow the method to perform
timing evaluations.
@type tim: C{sns_time.DiffTime}
"""
import common_lib
import dr_lib
import DST
if tim is not None:
tim.getTime(False)
old_time = tim.getOldTime()
if config.data is None:
raise RuntimeError("Need to pass a data filename to the driver "\
+"script.")
# Read in geometry if one is provided
if config.inst_geom is not None:
if config.verbose:
print "Reading in instrument geometry file"
inst_geom_dst = DST.getInstance("application/x-NxsGeom",
config.inst_geom)
else:
inst_geom_dst = None
# Perform early background subtraction if the hwfix flag is used
if config.hwfix:
if not config.mc:
so_axis = "time_of_flight"
else:
so_axis = "Time_of_Flight"
bkg_som0 = dr_lib.add_files(config.back,
Data_Paths=config.data_paths.toPath(),
SO_Axis=so_axis,
Signal_ROI=config.roi_file,
dataset_type="background",
Verbose=config.verbose, Timer=tim)
bkg_som = dr_lib.fix_bin_contents(bkg_som0)
del bkg_som0
else:
bkg_som = None
# Perform Steps 1-15 on sample data
d_som1 = dr_lib.process_igs_data(config.data, config, timer=tim,
inst_geom_dst=inst_geom_dst,
tib_const=config.tib_data_const,
bkg_som=bkg_som)
# Perform Steps 1-15 on empty can data
if config.ecan is not None:
e_som1 = dr_lib.process_igs_data(config.ecan, config, timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="empty_can",
tib_const=config.tib_ecan_const,
bkg_som=bkg_som)
else:
e_som1 = None
# Perform Steps 1-15 on normalization data
if config.norm is not None:
n_som1 = dr_lib.process_igs_data(config.norm, config, timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="normalization",
tib_const=config.tib_norm_const,
bkg_som=bkg_som)
else:
n_som1 = None
# Perform Steps 1-15 on background data
if config.back is not None:
b_som1 = dr_lib.process_igs_data(config.back, config, timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="background",
tib_const=config.tib_back_const,
bkg_som=bkg_som)
else:
b_som1 = None
# Perform Step 1-15 on direct scattering background data
if config.dsback is not None:
ds_som1 = dr_lib.process_igs_data(config.dsback, config, timer=tim,
inst_geom_dst=inst_geom_dst,
tib_const=config.tib_dsback_const,
dataset_type="dsbackground",
bkg_som=bkg_som)
# Note: time_zero_slope MUST be a tuple
if config.time_zero_slope is not None:
ds_som1.attr_list["Time_zero_slope"] = \
config.time_zero_slope.toValErrTuple()
# Note: time_zero_offset MUST be a tuple
if config.time_zero_offset is not None:
ds_som1.attr_list["Time_zero_offset"] = \
config.time_zero_offset.toValErrTuple()
# Step 16: Linearly interpolate TOF elastic range in direct scattering
# background data
# First convert TOF elastic range to appropriate pixel initial
# wavelengths
if config.verbose:
print "Determining initial wavelength range for elastic line"
if tim is not None:
tim.getTime(False)
if config.tof_elastic is None:
# Units are in microseconds
tof_elastic_range = (140300, 141300)
else:
tof_elastic_range = config.tof_elastic
ctof_elastic_low = dr_lib.convert_single_to_list(\
"tof_to_initial_wavelength_igs_lin_time_zero",
(tof_elastic_range[0], 0.0),
ds_som1)
ctof_elastic_high = dr_lib.convert_single_to_list(\
"tof_to_initial_wavelength_igs_lin_time_zero",
(tof_elastic_range[1], 0.0),
ds_som1)
ctof_elastic_range = [(ctof_elastic_low[i][0], ctof_elastic_high[i][0])
for i in xrange(len(ctof_elastic_low))]
if tim is not None:
tim.getTime(msg="After calculating initial wavelength range for "\
+"elastic line ")
del ctof_elastic_low, ctof_elastic_high
if config.split:
lambda_filter = [(d_som1[i].axis[0].val[0],
d_som1[i].axis[0].val[-1])
for i in xrange(len(d_som1))]
else:
lambda_filter = None
# Now interpolate spectra between TOF elastic range (converted to
# initial wavelength)
if config.verbose:
print "Linearly interpolating direct scattering spectra"
if tim is not None:
tim.getTime(False)
ds_som2 = dr_lib.lin_interpolate_spectra(ds_som1, ctof_elastic_range,
filter_axis=lambda_filter)
if tim is not None:
tim.getTime(msg="After linearly interpolating direct scattering "\
+"spectra ")
if config.dump_dslin:
ds_som2_1 = dr_lib.sum_all_spectra(ds_som2,\
rebin_axis=config.lambda_bins.toNessiList())
hlr_utils.write_file(config.output, "text/Spec", ds_som2_1,
output_ext="lin",
data_ext=config.ext_replacement,
path_replacement=config.path_replacement,
verbose=config.verbose,
message="dsbackground linear interpolation")
del ds_som2_1
del ds_som1
else:
ds_som2 = None
if inst_geom_dst is not None:
inst_geom_dst.release_resource()
# Steps 17-18: Subtract background spectrum from sample spectrum
if config.dsback is None:
back_som = b_som1
bkg_type = "background"
else:
back_som = ds_som2
bkg_type = "dsbackground"
d_som2 = dr_lib.subtract_bkg_from_data(d_som1, back_som,
verbose=config.verbose,
timer=tim,
dataset1="data",
dataset2=bkg_type,
scale=config.scale_bs)
if config.dsback is not None:
del ds_som2
# Step 19: Zero region outside TOF elastic for background for empty can
if config.dsback is None:
bcs_som = b_som1
cs_som = e_som1
else:
if config.verbose and b_som1 is not None:
print "Zeroing background spectra"
if tim is not None and b_som1 is not None:
tim.getTime(False)
bcs_som = dr_lib.zero_spectra(b_som1, ctof_elastic_range)
if tim is not None and b_som1 is not None:
tim.getTime(msg="After zeroing background spectra")
if config.verbose and e_som1 is not None:
print "Zeroing empty can spectra"
if tim is not None and e_som1 is not None:
tim.getTime(False)
cs_som = dr_lib.zero_spectra(e_som1, ctof_elastic_range)
if tim is not None and e_som1 is not None:
tim.getTime(msg="After zeroing empty can spectra")
del ctof_elastic_range
# Steps 20-21: Subtract background spectrum from empty can spectrum
e_som2 = dr_lib.subtract_bkg_from_data(cs_som, bcs_som,
verbose=config.verbose,
timer=tim,
dataset1="data-empty_can",
dataset2="background",
scale=config.scale_bcs)
# Steps 22-23: Subtract background spectrum from empty can spectrum for
# normalization
try:
config.pre_norm
except AttributeError:
config.pre_norm = False
if not config.pre_norm:
e_som3 = dr_lib.subtract_bkg_from_data(e_som1, b_som1,
verbose=config.verbose,
timer=tim,
dataset1="norm-empty_can",
dataset2="background",
scale=config.scale_bcn)
else:
e_som3 = None
# Steps 24-25: Subtract background spectrum from normalization spectrum
if not config.pre_norm:
n_som2 = dr_lib.subtract_bkg_from_data(n_som1, b_som1,
verbose=config.verbose,
timer=tim,
dataset1="normalization",
dataset2="background",
scale=config.scale_bn)
else:
n_som2 = n_som1
del b_som1, e_som1, bcs_som, cs_som
# Steps 26-27: Subtract empty can spectrum from sample spectrum
d_som3 = dr_lib.subtract_bkg_from_data(d_som2, e_som2,
verbose=config.verbose,
timer=tim,
dataset1="data",
dataset2="empty_can",
scale=config.scale_cs)
del d_som2, e_som2
# Steps 28-29: Subtract empty can spectrum from normalization spectrum
if not config.pre_norm:
n_som3 = dr_lib.subtract_bkg_from_data(n_som2, e_som3,
verbose=config.verbose,
timer=tim,
dataset1="normalization",
dataset2="empty_can",
scale=config.scale_cn)
else:
n_som3 = n_som2
del n_som2, e_som3
# Step 30-31: Integrate normalization spectra
if config.verbose and n_som3 is not None and not config.pre_norm:
print "Integrating normalization spectra"
if not config.pre_norm:
norm_int = dr_lib.integrate_spectra(n_som3, start=config.norm_start,
end=config.norm_end, norm=True)
else:
norm_int = n_som3
del n_som3
# Step 32: Normalize data by integrated values
if config.verbose and norm_int is not None:
print "Normalizing data by normalization data"
if norm_int is not None:
d_som4 = common_lib.div_ncerr(d_som3, norm_int)
else:
d_som4 = d_som3
if norm_int is not None:
if tim is not None:
tim.getTime(msg="After normalizing data ")
del d_som3, norm_int
if config.dump_norm:
if tim is not None:
tim.getTime(False)
hlr_utils.write_file(config.output, "text/Spec", d_som4,
output_ext="wvn",
data_ext=config.ext_replacement,
path_replacement=config.path_replacement,
verbose=config.verbose,
message="wavelength (vanadium norm) information")
if tim is not None:
tim.getTime(msg="After writing wavelength (vanadium norm) info ")
# Steps 33 to end: Creating S(Q,E)
if config.Q_bins is not None:
if config.verbose:
print "Creating 2D spectrum"
if tim is not None:
tim.getTime(False)
d_som5 = dr_lib.create_E_vs_Q_igs(d_som4,
config.E_bins.toNessiList(),
config.Q_bins.toNessiList(),
so_id="Full Detector",
y_label="counts",
y_units="counts / (ueV * A^-1)",
x_labels=["Q transfer",
"energy transfer"],
x_units=["1/Angstroms","ueV"],
split=config.split,
Q_filter=False,
configure=config)
if tim is not None:
tim.getTime(msg="After creation of final spectrum ")
del d_som4
# Steps 33 to 36: Create S(-cos(polar), E)
elif config.ncospol_bins is not None:
if config.verbose:
print "Convert wavelength to energy transfer"
if tim is not None:
tim.getTime(False)
d_som4a = dr_lib.energy_transfer(d_som4, "IGS", "Wavelength_final",
sa_norm=True, scale=True,
change_units=True)
if tim is not None:
tim.getTime(msg="After wavelength to energy transfer conversion ")
del d_som4
if config.verbose:
print "Creating 2D spectrum"
if tim is not None:
tim.getTime(False)
d_som5 = dr_lib.create_param_vs_Y(d_som4a, "polar",
"negcos_param_array",
config.ncospol_bins.toNessiList(),
rebin_axis=config.E_bins.toNessiList(),
y_label="counts",
y_units="counts / ueV",
x_labels=["-cos(polar)",
"Energy Transfer"],
x_units=["", "ueV"])
if tim is not None:
tim.getTime(msg="After creation of final spectrum ")
# If rescaling factor present, rescale the data
if config.rescale_final is not None and not config.split:
d_som6 = common_lib.mult_ncerr(d_som5, (config.rescale_final, 0.0))
else:
d_som6 = d_som5
if tim is None:
old_time = None
if not __name__ == "amorphous_reduction_sqe":
del d_som5
__write_output(d_som6, config, tim, old_time)
else:
if config.create_output:
del d_som5
__write_output(d_som6, config, tim, old_time)
else:
return d_som6
def run(config, tim=None):
"""
This method is where the data reduction process gets done.
@param config: Object containing the data reduction configuration
information.
@type config: L{hlr_utils.Configure}
@param tim: (OPTIONAL) Object that will allow the method to perform
timing evaluations.
@type tim: C{sns_time.DiffTime}
"""
import dr_lib
import DST
if tim is not None:
tim.getTime(False)
old_time = tim.getOldTime()
if config.data is None:
raise RuntimeError("Need to pass a data filename to the driver "\
+"script.")
# Read in geometry if one is provided
if config.inst_geom is not None:
if config.verbose:
print "Reading in instrument geometry file"
inst_geom_dst = DST.getInstance("application/x-NxsGeom",
config.inst_geom)
else:
inst_geom_dst = None
# Perform Steps 1-11 on sample data
d_som1 = dr_lib.process_sas_data(config.data, config, timer=tim,
inst_geom_dst=inst_geom_dst,
bkg_subtract=config.bkg_coeff,
acc_down_time=config.data_acc_down_time.toValErrTuple(),
bkg_scale=config.bkg_scale,
trans_data=config.data_trans)
# Perform Steps 1-11 on buffer/solvent only data
if config.solv is not None:
s_som1 = dr_lib.process_sas_data(config.solv, config, timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="solvent",
bkg_subtract=config.bkg_coeff,
acc_down_time=config.solv_acc_down_time.toValErrTuple(),
bkg_scale=config.bkg_scale,
trans_data=config.solv_trans)
else:
s_som1 = None
# Step 12: Subtract buffer/solvent only spectrum from sample spectrum
d_som2 = dr_lib.subtract_bkg_from_data(d_som1, s_som1,
verbose=config.verbose,
timer=tim,
dataset1="data",
dataset2="solvent")
del s_som1, d_som1
# Perform Steps 1-11 on empty-can data
if config.ecan is not None:
e_som1 = dr_lib.process_sas_data(config.ecan, config, timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="empty_can",
bkg_subtract=config.bkg_coeff,
acc_down_time=config.ecan_acc_down_time.toValErrTuple(),
bkg_scale=config.bkg_scale,
trans_data=config.ecan_trans)
else:
e_som1 = None
# Step 13: Subtract empty-can spectrum from sample spectrum
d_som3 = dr_lib.subtract_bkg_from_data(d_som2, e_som1,
verbose=config.verbose,
timer=tim,
dataset1="data",
dataset2="empty_can")
del e_som1, d_som2
# Perform Steps 1-11 on open beam data
if config.open is not None:
o_som1 = dr_lib.process_sas_data(config.open, config, timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="open_beam",
bkg_subtract=config.bkg_coeff,
acc_down_time=config.open_acc_down_time.toValErrTuple(),
bkg_scale=config.bkg_scale)
else:
o_som1 = None
# Step 14: Subtract open beam spectrum from sample spectrum
d_som4 = dr_lib.subtract_bkg_from_data(d_som3, o_som1,
verbose=config.verbose,
timer=tim,
dataset1="data",
dataset2="open_beam")
del o_som1, d_som3
# Perform Steps 1-11 on dark current data
if config.dkcur is not None:
dc_som1 = dr_lib.process_sas_data(config.open, config, timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="dark_current",
bkg_subtract=config.bkg_coeff)
else:
dc_som1 = None
# Step 15: Subtract dark current spectrum from sample spectrum
d_som5 = dr_lib.subtract_bkg_from_data(d_som4, dc_som1,
verbose=config.verbose,
timer=tim,
dataset1="data",
dataset2="dark_current")
del dc_som1, d_som4
# Create 2D distributions is necessary
if config.dump_Q_r:
d_som5_1 = dr_lib.create_param_vs_Y(d_som5, "radius", "param_array",
config.r_bins.toNessiList(),
rebin_axis=config.Q_bins.toNessiList(),
binnorm=True,
y_label="S",
y_units="Counts / A^-1 m",
x_labels=["Radius", "Q"],
x_units=["m", "1/Angstroms"])
hlr_utils.write_file(config.output, "text/Dave2d", d_som5_1,
output_ext="qvr", verbose=config.verbose,
data_ext=config.ext_replacement,
path_replacement=config.path_replacement,
message="S(r, Q) information")
del d_som5_1
if config.dump_Q_theta:
d_som5_1 = dr_lib.create_param_vs_Y(d_som5, "polar", "param_array",
config.theta_bins.toNessiList(),
rebin_axis=config.Q_bins.toNessiList(),
binnorm=True,
y_label="S",
y_units="Counts / A^-1 rads",
x_labels=["Polar Angle", "Q"],
x_units=["rads", "1/Angstroms"])
hlr_utils.write_file(config.output, "text/Dave2d", d_som5_1,
output_ext="qvt", verbose=config.verbose,
data_ext=config.ext_replacement,
path_replacement=config.path_replacement,
message="S(theta, Q) information")
del d_som5_1
# Steps 16 and 17: Rebin and sum all spectra
if config.verbose:
print "Rebinning and summing for final spectrum"
if tim is not None:
tim.getTime(False)
if config.dump_frac_rebin:
set_conf = config
else:
set_conf = None
d_som6 = dr_lib.sum_by_rebin_frac(d_som5, config.Q_bins.toNessiList(),
configure=set_conf)
if tim is not None:
tim.getTime(msg="After rebinning and summing for spectrum")
del d_som5
if config.facility == "LENS":
# Step 18: Scale final spectrum by Q bin centers
if config.verbose:
print "Scaling final spectrum by Q centers"
if tim is not None:
tim.getTime(False)
d_som7 = dr_lib.fix_bin_contents(d_som6, scale=True, width=True,
units="1/Angstroms")
if tim is not None:
tim.getTime(msg="After scaling final spectrum")
else:
d_som7 = d_som6
del d_som6
# If rescaling factor present, rescale the data
if config.rescale_final is not None:
import common_lib
d_som8 = common_lib.mult_ncerr(d_som7, (config.rescale_final, 0.0))
else:
d_som8 = d_som7
del d_som7
hlr_utils.write_file(config.output, "text/Spec", d_som8,
verbose=config.verbose,
replace_path=False,
replace_ext=False,
message="combined S(Q) information")
# Create 1D canSAS file
hlr_utils.write_file(config.output, "text/canSAS", d_som8,
verbose=config.verbose,
output_ext="xml",
data_ext=config.ext_replacement,
path_replacement=config.path_replacement,
message="combined S(Q) information")
d_som8.attr_list["config"] = config
hlr_utils.write_file(config.output, "text/rmd", d_som8,
output_ext="rmd",
data_ext=config.ext_replacement,
path_replacement=config.path_replacement,
verbose=config.verbose,
message="metadata")
if tim is not None:
tim.setOldTime(old_time)
tim.getTime(msg="Total Running Time")
def run(config, tim):
"""
This method is where the data reduction process gets done.
@param config: Object containing the data reduction configuration
information.
@type config: L{hlr_utils.Configure}
@param tim: Object that will allow the method to perform timing
evaluations.
@type tim: C{sns_time.DiffTime}
"""
import common_lib
import dr_lib
if tim is not None:
tim.getTime(False)
old_time = tim.getOldTime()
if config.data1 is None or config.data2 is None:
raise RuntimeError("Need to pass a data filename(s) to the driver "\
+"script.")
dst_type1 = hlr_utils.file_peeker(config.data1[0])
if config.verbose:
print "Initial file type (data set 1):", dst_type1
d_som1 = dr_lib.add_files(config.data1, dst_type=dst_type1,
Verbose=config.verbose,
Timer=tim)
dst_type2 = hlr_utils.file_peeker(config.data2[0])
if config.verbose:
print "Initial file type (data set 2):", dst_type2
d_som2 = dr_lib.add_files(config.data2, dst_type=dst_type2,
Verbose=config.verbose,
Timer=tim)
# Get requested simple math operation
func = common_lib.__getattribute__(config.operation)
d_som3 = func(d_som1, d_som2)
del d_som1, d_som2
# Rescale data if necessary
if config.rescale is not None:
d_som4 = common_lib.mult_ncerr(d_som3, (config.rescale, 0.0))
else:
d_som4 = d_som3
del d_som3
# Write out file after simple math operation
hlr_utils.write_file(config.output, dst_type1, d_som4,
verbose=config.verbose,
replace_ext=False,
path_replacement=config.path_replacement,
axis_ok=True,
message="operated file")
if tim is not None:
tim.setOldTime(old_time)
tim.getTime(msg="Total Running Time")
def run(config, tim):
"""
This method is where the data reduction process gets done.
@param config: Object containing the data reduction configuration
information.
@type config: L{hlr_utils.Configure}
@param tim: Object that will allow the method to perform timing
evaluations.
@type tim: C{sns_time.DiffTime}
"""
import common_lib
import dr_lib
if tim is not None:
tim.getTime(False)
old_time = tim.getOldTime()
if config.data1 is None or config.data2 is None:
raise RuntimeError("Need to pass a data filename(s) to the driver "\
+"script.")
dst_type1 = hlr_utils.file_peeker(config.data1[0])
if config.verbose:
print "Initial file type (data set 1):", dst_type1
d_som1 = dr_lib.add_files(config.data1,
dst_type=dst_type1,
Verbose=config.verbose,
Timer=tim)
dst_type2 = hlr_utils.file_peeker(config.data2[0])
if config.verbose:
print "Initial file type (data set 2):", dst_type2
d_som2 = dr_lib.add_files(config.data2,
dst_type=dst_type2,
Verbose=config.verbose,
Timer=tim)
# Get requested simple math operation
func = common_lib.__getattribute__(config.operation)
d_som3 = func(d_som1, d_som2)
del d_som1, d_som2
# Rescale data if necessary
if config.rescale is not None:
d_som4 = common_lib.mult_ncerr(d_som3, (config.rescale, 0.0))
else:
d_som4 = d_som3
del d_som3
# Write out file after simple math operation
hlr_utils.write_file(config.output,
dst_type1,
d_som4,
verbose=config.verbose,
replace_ext=False,
path_replacement=config.path_replacement,
axis_ok=True,
message="operated file")
if tim is not None:
tim.setOldTime(old_time)
tim.getTime(msg="Total Running Time")
def subtract_bkg_from_data(data_som, bkg_som, **kwargs):
"""
This function subtracts one data set from another.
@param data_som: Object containing the data to subtract from
@type data_som: C{SOM.SOM} or C{SOM.SO}
@param bkg_som: Object containing the data to be subtracted
@type bkg_som: C{SOM.SOM} or C{SOM.SO}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword dataset1: The type name of the first dataset. Default is
I{dataset1}.
@type dataset1: C{string}
@keyword dataset2: The type name of the second dataset. Default is
I{dataset2}.
@keyword scale: The constant by which to scale the background spectra
@type scale: L{hlr_utils.DrParameter}
@keyword verbose: A flag for turning on information from the function.
@type verbose: C{boolean}
@keyword timer: Timing object so the function can perform timing
@type timer: C{sns_timer.DiffTime}
@return: The data subtracted by the background
@rtype: C{SOM.SOM} or C{SOM.SO}
@raise TypeError: Both objects are not C{SOM}s, a C{SO} and a C{SOM} or
a C{SOM} and a C{SO}
"""
# Kickout if data object is NoneType
if data_som is None:
return None
# Kickout if background object is NoneType
if bkg_som is None:
return data_som
# import the helper functions
import hlr_utils
(data_descr, bkg_descr) = hlr_utils.get_descr(data_som, bkg_som)
if data_descr == "SOM" and bkg_descr == "SOM":
hlr_utils.math_compatible(data_som, data_descr, bkg_som, bkg_descr)
elif data_descr == "SOM" and bkg_descr == "SO" or \
data_descr == "SO" and bkg_descr == "SOM":
# You have SO-SOM or SOM-SO, so assume everything is OK
pass
else:
raise TypeError("The object combinations must be SOM-SOM, SO-SOM "\
+"or SOM-SO. You provided a %s and a %s" % \
(data_descr, bkg_descr))
# Check for keywords
try:
verbose = kwargs["verbose"]
except KeyError:
verbose = False
try:
t = kwargs["timer"]
except KeyError:
t = None
try:
dataset1 = kwargs["dataset1"]
except KeyError:
dataset1 = "dataset1"
try:
dataset2 = kwargs["dataset2"]
except KeyError:
dataset2 = "dataset2"
try:
scale = kwargs["scale"]
except KeyError:
scale = None
import common_lib
if scale is not None:
if verbose:
print "Scaling %s for %s" % (dataset2, dataset1)
bkg_som2 = common_lib.mult_ncerr(bkg_som, scale.toValErrTuple())
if t is not None:
t.getTime(msg="After scaling %s for %s " % (dataset2, dataset1))
else:
bkg_som2 = bkg_som
del bkg_som
if verbose:
print "Subtracting %s from %s" % (dataset2, dataset1)
data_som2 = common_lib.sub_ncerr(data_som, bkg_som2)
if t is not None:
t.getTime(msg="After subtracting %s from %s " % (dataset2, dataset1))
return data_som2
def process_dgs_data(obj, conf, bcan, ecan, tcoeff, **kwargs):
"""
This function combines Steps 7 through 16 in Section 2.1.1 of the data
reduction process for Direct Geometry Spectrometers as specified by the
document at
U{http://neutrons.ornl.gov/asg/projects/SCL/reqspec/DR_Lib_RS.doc}. The
function takes a calibrated dataset, a L{hlr_utils.Configure} object and
processes the data accordingly.
@param obj: A calibrated dataset object.
@type obj: C{SOM.SOM}
@param conf: Object that contains the current setup of the driver.
@type conf: L{hlr_utils.Configure}
@param bcan: The object containing the black can data.
@type bcan: C{SOM.SOM}
@param ecan: The object containing the empty can data.
@type ecan: C{SOM.SOM}
@param tcoeff: The transmission coefficient appropriate to the given data
set.
@type tcoeff: C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword dataset_type: The practical name of the dataset being processed.
The default value is I{data}.
@type dataset_type: C{string}
@keyword cwp_used: A flag signalling the use of the chopper phase
corrections.
@type cwp_used: C{bool}
@keyword timer: Timing object so the function can perform timing estimates.
@type timer: C{sns_timer.DiffTime}
@return: Object that has undergone all requested processing steps
@rtype: C{SOM.SOM}
"""
import array_manip
import common_lib
import dr_lib
import hlr_utils
# Check keywords
try:
dataset_type = kwargs["dataset_type"]
except KeyError:
dataset_type = "data"
try:
t = kwargs["timer"]
except KeyError:
t = None
cwp_used = kwargs.get("cwp_used", False)
if conf.verbose:
print "Processing %s information" % dataset_type
# Step 7: Create black can background contribution
if bcan is not None:
if conf.verbose:
print "Creating black can background contribution for %s" \
% dataset_type
if t is not None:
t.getTime(False)
bccoeff = array_manip.sub_ncerr(1.0, 0.0, tcoeff[0], tcoeff[1])
bcan1 = common_lib.mult_ncerr(bcan, bccoeff)
if t is not None:
t.getTime(msg="After creating black can background contribution ")
del bcan
else:
bcan1 = None
# Step 8: Create empty can background contribution
if ecan is not None:
if conf.verbose:
print "Creating empty can background contribution for %s" \
% dataset_type
if t is not None:
t.getTime(False)
ecan1 = common_lib.mult_ncerr(ecan, tcoeff)
if t is not None:
t.getTime(msg="After creating empty can background contribution ")
del ecan
else:
ecan1 = None
# Step 9: Create background spectra
if bcan1 is not None or ecan1 is not None and conf.verbose:
print "Creating background spectra for %s" % dataset_type
if bcan1 is not None and ecan1 is not None:
if cwp_used:
if conf.verbose:
print "Rebinning empty can to black can axis."
ecan2 = common_lib.rebin_axis_1D_frac(ecan1, bcan1[0].axis[0].val)
else:
ecan2 = ecan1
del ecan1
if t is not None:
t.getTime(False)
b_som = common_lib.add_ncerr(bcan1, ecan2)
if t is not None:
t.getTime(msg="After creating background spectra ")
elif bcan1 is not None and ecan1 is None:
b_som = bcan1
elif bcan1 is None and ecan1 is not None:
b_som = ecan1
else:
b_som = None
del bcan1, ecan1
if cwp_used:
if conf.verbose:
print "Rebinning background spectra to %s" % dataset_type
b_som1 = common_lib.rebin_axis_1D_frac(b_som, obj[0].axis[0].val)
else:
b_som1 = b_som
del b_som
if conf.dump_ctof_comb and b_som1 is not None:
b_som_1 = dr_lib.sum_all_spectra(b_som1)
hlr_utils.write_file(conf.output,
"text/Spec",
b_som_1,
output_ext="ctof",
extra_tag="background",
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
verbose=conf.verbose,
message="combined background TOF information")
del b_som_1
# Step 10: Subtract background from data
obj1 = dr_lib.subtract_bkg_from_data(obj,
b_som1,
verbose=conf.verbose,
timer=t,
dataset1=dataset_type,
dataset2="background")
del obj, b_som1
# Step 11: Calculate initial velocity
if conf.verbose:
print "Calculating initial velocity"
if t is not None:
t.getTime(False)
if conf.initial_energy is not None:
initial_wavelength = common_lib.energy_to_wavelength(\
conf.initial_energy.toValErrTuple())
initial_velocity = common_lib.wavelength_to_velocity(\
initial_wavelength)
else:
# This should actually calculate it, but don't have a way right now
pass
if t is not None:
t.getTime(msg="After calculating initial velocity ")
# Step 12: Calculate the time-zero offset
if conf.time_zero_offset is not None:
time_zero_offset = conf.time_zero_offset.toValErrTuple()
else:
# This should actually calculate it, but don't have a way right now
time_zero_offset = (0.0, 0.0)
# Step 13: Convert time-of-flight to final velocity
if conf.verbose:
print "Converting TOF to final velocity DGS"
if t is not None:
t.getTime(False)
obj2 = common_lib.tof_to_final_velocity_dgs(obj1,
initial_velocity,
time_zero_offset,
units="microsecond")
if t is not None:
t.getTime(msg="After calculating TOF to final velocity DGS ")
del obj1
# Step 14: Convert final velocity to final wavelength
if conf.verbose:
print "Converting final velocity DGS to final wavelength"
if t is not None:
t.getTime(False)
obj3 = common_lib.velocity_to_wavelength(obj2)
if t is not None:
t.getTime(msg="After calculating velocity to wavelength ")
del obj2
if conf.dump_wave_comb:
obj3_1 = dr_lib.sum_all_spectra(
obj3, rebin_axis=conf.lambda_bins.toNessiList())
hlr_utils.write_file(conf.output,
"text/Spec",
obj3_1,
output_ext="fwv",
extra_tag=dataset_type,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
verbose=conf.verbose,
message="combined final wavelength information")
del obj3_1
# Step 15: Create the detector efficiency
if conf.det_eff is not None:
if conf.verbose:
print "Creating detector efficiency spectra"
if t is not None:
t.getTime(False)
det_eff = dr_lib.create_det_eff(obj3)
if t is not None:
t.getTime(msg="After creating detector efficiency spectra ")
else:
det_eff = None
# Step 16: Divide the detector pixel spectra by the detector efficiency
if det_eff is not None:
if conf.verbose:
print "Correcting %s for detector efficiency" % dataset_type
if t is not None:
t.getTime(False)
obj4 = common_lib.div_ncerr(obj3, det_eff)
if t is not None:
t.getTime(msg="After correcting %s for detector efficiency" \
% dataset_type)
else:
obj4 = obj3
del obj3, det_eff
return obj4
def process_igs_data(datalist, conf, **kwargs):
"""
This function combines Steps 1 through 8 of the data reduction process for
Inverse Geometry Spectrometers as specified by the documents at
U{http://neutrons.ornl.gov/asg/projects/SCL/reqspec/DR_Lib_RS.doc}. The
function takes a list of file names, a L{hlr_utils.Configure} object and
processes the data accordingly. This function should really only be used in
the context of I{amorphous_reduction} and I{calc_norm_eff}.
@param datalist: A list containing the filenames of the data to be
processed.
@type datalist: C{list} of C{string}s
@param conf: Object that contains the current setup of the driver.
@type conf: L{hlr_utils.Configure}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword inst_geom_dst: File object that contains instrument geometry
information.
@type inst_geom_dst: C{DST.GeomDST}
@keyword dataset_type: The practical name of the dataset being processed.
The default value is I{data}.
@type dataset_type: C{string}
@keyword tib_const: Object providing the time-independent background
constant to subtract.
@type tib_const: L{hlr_utils.DrParameter}
@keyword bkg_som: Object that will be used for early background subtraction
@type bkg_som: C{SOM.SOM}
@keyword timer: Timing object so the function can perform timing estimates.
@type timer: C{sns_timer.DiffTime}
@return: Object that has undergone all requested processing steps
@rtype: C{SOM.SOM}
"""
import hlr_utils
# Check keywords
try:
dataset_type = kwargs["dataset_type"]
except KeyError:
dataset_type = "data"
try:
t = kwargs["timer"]
except KeyError:
t = None
try:
if kwargs["tib_const"] is not None:
tib_const = kwargs["tib_const"].toValErrTuple()
else:
tib_const = None
except KeyError:
tib_const = None
try:
i_geom_dst = kwargs["inst_geom_dst"]
except KeyError:
i_geom_dst = None
try:
bkg_som = kwargs["bkg_som"]
except KeyError:
bkg_som = None
# Step 1: Open appropriate data files
if not conf.mc:
so_axis = "time_of_flight"
else:
so_axis = "Time_of_Flight"
# Add so_axis to Configure object
conf.so_axis = so_axis
if conf.verbose:
print "Reading %s file" % dataset_type
# Special case handling for normalization data. Dynamically trying to
# determine if incoming file is a previously calculated one.
if dataset_type == "normalization":
try:
# Check the first incoming file
dst_type = hlr_utils.file_peeker(datalist[0])
# If file_peeker succeeds, the DST is different than the function
# returns
dst_type = "text/num-info"
# Let ROI file handle filtering
data_paths = None
except RuntimeError:
# It's a NeXus file
dst_type = "application/x-NeXus"
data_paths = conf.data_paths.toPath()
else:
dst_type = "application/x-NeXus"
data_paths = conf.data_paths.toPath()
# The [0] is to get the data SOM and ignore the None background SOM
dp_som0 = dr_lib.add_files(datalist,
Data_Paths=data_paths,
SO_Axis=so_axis,
Signal_ROI=conf.roi_file,
dataset_type=dataset_type,
dst_type=dst_type,
Verbose=conf.verbose,
Timer=t)
if t is not None:
t.getTime(msg="After reading %s " % dataset_type)
if dst_type == "text/num-info":
# Since we have a pre-calculated normalization dataset, set the flag
# and return the SOM now
conf.pre_norm = True
# Make the labels and units compatible with a NeXus file based SOM
dp_som0.setAxisLabel(0, "wavelength")
dp_som0.setAxisUnits(0, "Angstroms")
dp_som0.setYUnits("Counts/A")
return dp_som0
else:
if dataset_type == "normalization":
# Since we have a NeXus file, we need to continue
conf.pre_norm = False
# Cut the spectra if necessary
dp_somA = dr_lib.cut_spectra(dp_som0, conf.tof_cut_min, conf.tof_cut_max)
del dp_som0
dp_som1 = dr_lib.fix_bin_contents(dp_somA)
del dp_somA
if conf.inst_geom is not None:
i_geom_dst.setGeometry(conf.data_paths.toPath(), dp_som1)
if conf.no_mon_norm:
dm_som1 = None
else:
if conf.verbose:
print "Reading in monitor data from %s file" % dataset_type
# The [0] is to get the data SOM and ignore the None background SOM
dm_som0 = dr_lib.add_files(datalist,
Data_Paths=conf.mon_path.toPath(),
SO_Axis=so_axis,
dataset_type=dataset_type,
Verbose=conf.verbose,
Timer=t)
if t is not None:
t.getTime(msg="After reading monitor data ")
dm_som1 = dr_lib.fix_bin_contents(dm_som0)
del dm_som0
if conf.inst_geom is not None:
i_geom_dst.setGeometry(conf.mon_path.toPath(), dm_som1)
if bkg_som is not None:
bkg_pcharge = bkg_som.attr_list["background-proton_charge"].getValue()
data_pcharge = dp_som1.attr_list[dataset_type +
"-proton_charge"].getValue()
ratio = data_pcharge / bkg_pcharge
bkg_som1 = common_lib.mult_ncerr(bkg_som, (ratio, 0.0))
del bkg_som
dp_som2 = dr_lib.subtract_bkg_from_data(dp_som1,
bkg_som1,
verbose=conf.verbose,
timer=t,
dataset1=dataset_type,
dataset2="background")
else:
dp_som2 = dp_som1
del dp_som1
# Step 2: Dead Time Correction
# No dead time correction is being applied to the data yet
# Step 3: Time-independent background determination
if conf.verbose and conf.tib_tofs is not None:
print "Determining time-independent background from data"
if t is not None and conf.tib_tofs is not None:
t.getTime(False)
B = dr_lib.determine_time_indep_bkg(dp_som2, conf.tib_tofs)
if t is not None and B is not None:
t.getTime(msg="After determining time-independent background ")
if conf.dump_tib and B is not None:
file_comment = "TOFs: %s" % conf.tib_tofs
hlr_utils.write_file(conf.output, "text/num-info", B,
output_ext="tib",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="time-independent background "\
+"information",
tag="Average",
units="counts",
comments=[file_comment])
# Step 4: Subtract time-independent background
if conf.verbose and B is not None:
print "Subtracting time-independent background from data"
if t is not None:
t.getTime(False)
if B is not None:
dp_som3 = common_lib.sub_ncerr(dp_som2, B)
else:
dp_som3 = dp_som2
if B is not None and t is not None:
t.getTime(msg="After subtracting time-independent background ")
del dp_som2, B
# Step 5: Subtract time-independent background constant
if conf.verbose and tib_const is not None:
print "Subtracting time-independent background constant from data"
if t is not None and tib_const is not None:
t.getTime(False)
if tib_const is not None:
dp_som4 = common_lib.sub_ncerr(dp_som3, tib_const)
else:
dp_som4 = dp_som3
if t is not None and tib_const is not None:
t.getTime(msg="After subtracting time-independent background "\
+"constant ")
del dp_som3
# Provide override capability for final wavelength, time-zero slope and
# time-zero offset
if conf.wavelength_final is not None:
dp_som4.attr_list["Wavelength_final"] = \
conf.wavelength_final.toValErrTuple()
# Note: time_zero_slope MUST be a tuple
if conf.time_zero_slope is not None:
dp_som4.attr_list["Time_zero_slope"] = \
conf.time_zero_slope.toValErrTuple()
if dm_som1 is not None:
dm_som1.attr_list["Time_zero_slope"] = \
conf.time_zero_slope.toValErrTuple()
# Note: time_zero_offset MUST be a tuple
if conf.time_zero_offset is not None:
dp_som4.attr_list["Time_zero_offset"] = \
conf.time_zero_offset.toValErrTuple()
if dm_som1 is not None:
dm_som1.attr_list["Time_zero_offset"] = \
conf.time_zero_offset.toValErrTuple()
# Step 6: Convert TOF to wavelength for data and monitor
if conf.verbose:
print "Converting TOF to wavelength"
if t is not None:
t.getTime(False)
# Convert monitor
if dm_som1 is not None:
dm_som2 = common_lib.tof_to_wavelength_lin_time_zero(
dm_som1, units="microsecond")
else:
dm_som2 = None
# Convert detector pixels
dp_som5 = common_lib.tof_to_initial_wavelength_igs_lin_time_zero(
dp_som4, units="microsecond", run_filter=conf.filter)
if t is not None:
t.getTime(msg="After converting TOF to wavelength ")
if conf.dump_wave:
hlr_utils.write_file(conf.output,
"text/Spec",
dp_som5,
output_ext="pxl",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="pixel wavelength information")
if conf.dump_mon_wave and dm_som2 is not None:
hlr_utils.write_file(conf.output,
"text/Spec",
dm_som2,
output_ext="mxl",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="monitor wavelength information")
del dp_som4, dm_som1
# Step 7: Efficiency correct monitor
if conf.verbose and dm_som2 is not None and not conf.no_mon_effc:
print "Efficiency correct monitor data"
if t is not None:
t.getTime(False)
if not conf.no_mon_effc:
dm_som3 = dr_lib.feff_correct_mon(dm_som2)
else:
dm_som3 = dm_som2
if t is not None and dm_som2 is not None and not conf.no_mon_effc:
t.getTime(msg="After efficiency correcting monitor ")
if conf.dump_mon_effc and not conf.no_mon_effc and dm_som3 is not None:
hlr_utils.write_file(conf.output, "text/Spec", dm_som3,
output_ext="mel",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="monitor wavelength information "\
+"(efficiency)")
del dm_som2
# Step 8: Rebin monitor axis onto detector pixel axis
if conf.verbose and dm_som3 is not None:
print "Rebin monitor axis to detector pixel axis"
if t is not None:
t.getTime(False)
dm_som4 = dr_lib.rebin_monitor(dm_som3, dp_som5)
if t is not None and dm_som4 is not None:
t.getTime(msg="After rebinning monitor ")
del dm_som3
if conf.dump_mon_rebin and dm_som4 is not None:
hlr_utils.write_file(conf.output, "text/Spec", dm_som4,
output_ext="mrl",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="monitor wavelength information "\
+"(rebinned)")
# The lambda-dependent background is only done on sample data (aka data)
# for the BSS instrument at the SNS
if conf.inst == "BSS" and conf.ldb_const is not None and \
dataset_type == "data":
# Step 9: Convert chopper center wavelength to TOF center
if conf.verbose:
print "Converting chopper center wavelength to TOF"
if t is not None:
t.getTime(False)
tof_center = dr_lib.convert_single_to_list(\
"initial_wavelength_igs_lin_time_zero_to_tof",
conf.chopper_lambda_cent.toValErrTuple(), dp_som5)
# Step 10: Calculate beginning and end of detector TOF spectrum
if conf.verbose:
print "Calculating beginning and ending TOF ranges"
half_inv_chop_freq = 0.5 / conf.chopper_freq.toValErrTuple()[0]
# Above is in seconds, need microseconds
half_inv_chop_freq *= 1.0e6
tof_begin = common_lib.sub_ncerr(tof_center, (half_inv_chop_freq, 0.0))
tof_end = common_lib.add_ncerr(tof_center, (half_inv_chop_freq, 0.0))
# Step 11: Convert TOF_begin and TOF_end to wavelength
if conf.verbose:
print "Converting TOF_begin and TOF_end to wavelength"
# Check for time-zero slope information
try:
tz_slope = conf.time_zero_slope.toValErrTuple()
except AttributeError:
tz_slope = (0.0, 0.0)
# Check for time-zero offset information
try:
tz_offset = conf.time_zero_offset.toValErrTuple()
except AttributeError:
tz_offset = (0.0, 0.0)
l_begin = common_lib.tof_to_initial_wavelength_igs_lin_time_zero(\
tof_begin, time_zero_slope=tz_slope, time_zero_offset=tz_offset,
iobj=dp_som5, run_filter=False)
l_end = common_lib.tof_to_initial_wavelength_igs_lin_time_zero(\
tof_end, time_zero_slope=tz_slope, time_zero_offset=tz_offset,
iobj=dp_som5, run_filter=False)
# Step 12: tof-least-bkg to lambda-least-bkg
if conf.verbose:
print "Converting TOF least background to wavelength"
lambda_least_bkg = dr_lib.convert_single_to_list(\
"tof_to_initial_wavelength_igs_lin_time_zero",
conf.tof_least_bkg.toValErrTuple(), dp_som5)
if t is not None:
t.getTime(msg="After converting boundary positions ")
# Step 13: Create lambda-dependent background spectrum
if conf.verbose:
print "Creating lambda-dependent background spectra"
if t is not None:
t.getTime(False)
ldb_som = dr_lib.shift_spectrum(dm_som4, lambda_least_bkg, l_begin,
l_end, conf.ldb_const.getValue())
if t is not None:
t.getTime(msg="After creating lambda-dependent background "\
+"spectra ")
# Step 14: Subtract lambda-dependent background from sample data
if conf.verbose:
print "Subtracting lambda-dependent background from data"
if t is not None:
t.getTime(False)
dp_som6 = common_lib.sub_ncerr(dp_som5, ldb_som)
if t is not None:
t.getTime(msg="After subtracting lambda-dependent background "\
+"from data ")
else:
dp_som6 = dp_som5
del dp_som5
# Step 15: Normalize data by monitor
if conf.verbose and dm_som4 is not None:
print "Normalizing data by monitor"
if t is not None:
t.getTime(False)
if dm_som4 is not None:
dp_som7 = common_lib.div_ncerr(dp_som6, dm_som4)
if t is not None:
t.getTime(msg="After normalizing data by monitor ")
else:
dp_som7 = dp_som6
if conf.dump_wave_mnorm:
dp_som7_1 = dr_lib.sum_all_spectra(dp_som7,\
rebin_axis=conf.lambda_bins.toNessiList())
write_message = "combined pixel wavelength information"
if dm_som4 is not None:
write_message += " (monitor normalized)"
hlr_utils.write_file(conf.output,
"text/Spec",
dp_som7_1,
output_ext="pml",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message=write_message)
del dp_som7_1
del dm_som4, dp_som6
return dp_som7
def subtract_bkg_from_data(data_som, bkg_som, **kwargs):
"""
This function subtracts one data set from another.
@param data_som: Object containing the data to subtract from
@type data_som: C{SOM.SOM} or C{SOM.SO}
@param bkg_som: Object containing the data to be subtracted
@type bkg_som: C{SOM.SOM} or C{SOM.SO}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword dataset1: The type name of the first dataset. Default is
I{dataset1}.
@type dataset1: C{string}
@keyword dataset2: The type name of the second dataset. Default is
I{dataset2}.
@keyword scale: The constant by which to scale the background spectra
@type scale: L{hlr_utils.DrParameter}
@keyword verbose: A flag for turning on information from the function.
@type verbose: C{boolean}
@keyword timer: Timing object so the function can perform timing
@type timer: C{sns_timer.DiffTime}
@return: The data subtracted by the background
@rtype: C{SOM.SOM} or C{SOM.SO}
@raise TypeError: Both objects are not C{SOM}s, a C{SO} and a C{SOM} or
a C{SOM} and a C{SO}
"""
# Kickout if data object is NoneType
if data_som is None:
return None
# Kickout if background object is NoneType
if bkg_som is None:
return data_som
# import the helper functions
import hlr_utils
(data_descr, bkg_descr) = hlr_utils.get_descr(data_som, bkg_som)
if data_descr == "SOM" and bkg_descr == "SOM":
hlr_utils.math_compatible(data_som, data_descr, bkg_som, bkg_descr)
elif data_descr == "SOM" and bkg_descr == "SO" or \
data_descr == "SO" and bkg_descr == "SOM":
# You have SO-SOM or SOM-SO, so assume everything is OK
pass
else:
raise TypeError("The object combinations must be SOM-SOM, SO-SOM "\
+"or SOM-SO. You provided a %s and a %s" % \
(data_descr, bkg_descr))
# Check for keywords
try:
verbose = kwargs["verbose"]
except KeyError:
verbose = False
try:
t = kwargs["timer"]
except KeyError:
t = None
try:
dataset1 = kwargs["dataset1"]
except KeyError:
dataset1 = "dataset1"
try:
dataset2 = kwargs["dataset2"]
except KeyError:
dataset2 = "dataset2"
try:
scale = kwargs["scale"]
except KeyError:
scale = None
import common_lib
if scale is not None:
if verbose:
print "Scaling %s for %s" % (dataset2, dataset1)
bkg_som2 = common_lib.mult_ncerr(bkg_som, scale.toValErrTuple())
if t is not None:
t.getTime(msg="After scaling %s for %s " % (dataset2, dataset1))
else:
bkg_som2 = bkg_som
del bkg_som
if verbose:
print "Subtracting %s from %s" % (dataset2, dataset1)
data_som2 = common_lib.sub_ncerr(data_som, bkg_som2)
if t is not None:
t.getTime(msg="After subtracting %s from %s " % (dataset2, dataset1))
return data_som2
def run(config, tim=None):
"""
This method is where the data reduction process gets done.
@param config: Object containing the data reduction configuration
information.
@type config: L{hlr_utils.Configure}
@param tim: (OPTIONAL) Object that will allow the method to perform
timing evaluations.
@type tim: C{sns_time.DiffTime}
"""
import common_lib
import dr_lib
import DST
if tim is not None:
tim.getTime(False)
old_time = tim.getOldTime()
if config.data is None:
raise RuntimeError("Need to pass a data filename to the driver "\
+"script.")
# Read in geometry if one is provided
if config.inst_geom is not None:
if config.verbose:
print "Reading in instrument geometry file"
inst_geom_dst = DST.getInstance("application/x-NxsGeom",
config.inst_geom)
else:
inst_geom_dst = None
# Perform early background subtraction if the hwfix flag is used
if config.hwfix:
if not config.mc:
so_axis = "time_of_flight"
else:
so_axis = "Time_of_Flight"
bkg_som0 = dr_lib.add_files(config.back,
Data_Paths=config.data_paths.toPath(),
SO_Axis=so_axis,
Signal_ROI=config.roi_file,
dataset_type="background",
Verbose=config.verbose,
Timer=tim)
bkg_som = dr_lib.fix_bin_contents(bkg_som0)
del bkg_som0
else:
bkg_som = None
# Perform Steps 1-15 on sample data
d_som1 = dr_lib.process_igs_data(config.data,
config,
timer=tim,
inst_geom_dst=inst_geom_dst,
tib_const=config.tib_data_const,
bkg_som=bkg_som)
# Perform Steps 1-15 on empty can data
if config.ecan is not None:
e_som1 = dr_lib.process_igs_data(config.ecan,
config,
timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="empty_can",
tib_const=config.tib_ecan_const,
bkg_som=bkg_som)
else:
e_som1 = None
# Perform Steps 1-15 on normalization data
if config.norm is not None:
n_som1 = dr_lib.process_igs_data(config.norm,
config,
timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="normalization",
tib_const=config.tib_norm_const,
bkg_som=bkg_som)
else:
n_som1 = None
# Perform Steps 1-15 on background data
if config.back is not None:
b_som1 = dr_lib.process_igs_data(config.back,
config,
timer=tim,
inst_geom_dst=inst_geom_dst,
dataset_type="background",
tib_const=config.tib_back_const,
bkg_som=bkg_som)
else:
b_som1 = None
# Perform Step 1-15 on direct scattering background data
if config.dsback is not None:
ds_som1 = dr_lib.process_igs_data(config.dsback,
config,
timer=tim,
inst_geom_dst=inst_geom_dst,
tib_const=config.tib_dsback_const,
dataset_type="dsbackground",
bkg_som=bkg_som)
# Note: time_zero_slope MUST be a tuple
if config.time_zero_slope is not None:
ds_som1.attr_list["Time_zero_slope"] = \
config.time_zero_slope.toValErrTuple()
# Note: time_zero_offset MUST be a tuple
if config.time_zero_offset is not None:
ds_som1.attr_list["Time_zero_offset"] = \
config.time_zero_offset.toValErrTuple()
# Step 16: Linearly interpolate TOF elastic range in direct scattering
# background data
# First convert TOF elastic range to appropriate pixel initial
# wavelengths
if config.verbose:
print "Determining initial wavelength range for elastic line"
if tim is not None:
tim.getTime(False)
if config.tof_elastic is None:
# Units are in microseconds
tof_elastic_range = (140300, 141300)
else:
tof_elastic_range = config.tof_elastic
ctof_elastic_low = dr_lib.convert_single_to_list(\
"tof_to_initial_wavelength_igs_lin_time_zero",
(tof_elastic_range[0], 0.0),
ds_som1)
ctof_elastic_high = dr_lib.convert_single_to_list(\
"tof_to_initial_wavelength_igs_lin_time_zero",
(tof_elastic_range[1], 0.0),
ds_som1)
ctof_elastic_range = [(ctof_elastic_low[i][0], ctof_elastic_high[i][0])
for i in xrange(len(ctof_elastic_low))]
if tim is not None:
tim.getTime(msg="After calculating initial wavelength range for "\
+"elastic line ")
del ctof_elastic_low, ctof_elastic_high
if config.split:
lambda_filter = [(d_som1[i].axis[0].val[0],
d_som1[i].axis[0].val[-1])
for i in xrange(len(d_som1))]
else:
lambda_filter = None
# Now interpolate spectra between TOF elastic range (converted to
# initial wavelength)
if config.verbose:
print "Linearly interpolating direct scattering spectra"
if tim is not None:
tim.getTime(False)
ds_som2 = dr_lib.lin_interpolate_spectra(ds_som1,
ctof_elastic_range,
filter_axis=lambda_filter)
if tim is not None:
tim.getTime(msg="After linearly interpolating direct scattering "\
+"spectra ")
if config.dump_dslin:
ds_som2_1 = dr_lib.sum_all_spectra(ds_som2,\
rebin_axis=config.lambda_bins.toNessiList())
hlr_utils.write_file(config.output,
"text/Spec",
ds_som2_1,
output_ext="lin",
data_ext=config.ext_replacement,
path_replacement=config.path_replacement,
verbose=config.verbose,
message="dsbackground linear interpolation")
del ds_som2_1
del ds_som1
else:
ds_som2 = None
if inst_geom_dst is not None:
inst_geom_dst.release_resource()
# Steps 17-18: Subtract background spectrum from sample spectrum
if config.dsback is None:
back_som = b_som1
bkg_type = "background"
else:
back_som = ds_som2
bkg_type = "dsbackground"
d_som2 = dr_lib.subtract_bkg_from_data(d_som1,
back_som,
verbose=config.verbose,
timer=tim,
dataset1="data",
dataset2=bkg_type,
scale=config.scale_bs)
if config.dsback is not None:
del ds_som2
# Step 19: Zero region outside TOF elastic for background for empty can
if config.dsback is None:
bcs_som = b_som1
cs_som = e_som1
else:
if config.verbose and b_som1 is not None:
print "Zeroing background spectra"
if tim is not None and b_som1 is not None:
tim.getTime(False)
bcs_som = dr_lib.zero_spectra(b_som1, ctof_elastic_range)
if tim is not None and b_som1 is not None:
tim.getTime(msg="After zeroing background spectra")
if config.verbose and e_som1 is not None:
print "Zeroing empty can spectra"
if tim is not None and e_som1 is not None:
tim.getTime(False)
cs_som = dr_lib.zero_spectra(e_som1, ctof_elastic_range)
if tim is not None and e_som1 is not None:
tim.getTime(msg="After zeroing empty can spectra")
del ctof_elastic_range
# Steps 20-21: Subtract background spectrum from empty can spectrum
e_som2 = dr_lib.subtract_bkg_from_data(cs_som,
bcs_som,
verbose=config.verbose,
timer=tim,
dataset1="data-empty_can",
dataset2="background",
scale=config.scale_bcs)
# Steps 22-23: Subtract background spectrum from empty can spectrum for
# normalization
try:
config.pre_norm
except AttributeError:
config.pre_norm = False
if not config.pre_norm:
e_som3 = dr_lib.subtract_bkg_from_data(e_som1,
b_som1,
verbose=config.verbose,
timer=tim,
dataset1="norm-empty_can",
dataset2="background",
scale=config.scale_bcn)
else:
e_som3 = None
# Steps 24-25: Subtract background spectrum from normalization spectrum
if not config.pre_norm:
n_som2 = dr_lib.subtract_bkg_from_data(n_som1,
b_som1,
verbose=config.verbose,
timer=tim,
dataset1="normalization",
dataset2="background",
scale=config.scale_bn)
else:
n_som2 = n_som1
del b_som1, e_som1, bcs_som, cs_som
# Steps 26-27: Subtract empty can spectrum from sample spectrum
d_som3 = dr_lib.subtract_bkg_from_data(d_som2,
e_som2,
verbose=config.verbose,
timer=tim,
dataset1="data",
dataset2="empty_can",
scale=config.scale_cs)
del d_som2, e_som2
# Steps 28-29: Subtract empty can spectrum from normalization spectrum
if not config.pre_norm:
n_som3 = dr_lib.subtract_bkg_from_data(n_som2,
e_som3,
verbose=config.verbose,
timer=tim,
dataset1="normalization",
dataset2="empty_can",
scale=config.scale_cn)
else:
n_som3 = n_som2
del n_som2, e_som3
# Step 30-31: Integrate normalization spectra
if config.verbose and n_som3 is not None and not config.pre_norm:
print "Integrating normalization spectra"
if not config.pre_norm:
norm_int = dr_lib.integrate_spectra(n_som3,
start=config.norm_start,
end=config.norm_end,
norm=True)
else:
norm_int = n_som3
del n_som3
# Step 32: Normalize data by integrated values
if config.verbose and norm_int is not None:
print "Normalizing data by normalization data"
if norm_int is not None:
d_som4 = common_lib.div_ncerr(d_som3, norm_int)
else:
d_som4 = d_som3
if norm_int is not None:
if tim is not None:
tim.getTime(msg="After normalizing data ")
del d_som3, norm_int
if config.dump_norm:
if tim is not None:
tim.getTime(False)
hlr_utils.write_file(config.output,
"text/Spec",
d_som4,
output_ext="wvn",
data_ext=config.ext_replacement,
path_replacement=config.path_replacement,
verbose=config.verbose,
message="wavelength (vanadium norm) information")
if tim is not None:
tim.getTime(msg="After writing wavelength (vanadium norm) info ")
# Steps 33 to end: Creating S(Q,E)
if config.Q_bins is not None:
if config.verbose:
print "Creating 2D spectrum"
if tim is not None:
tim.getTime(False)
d_som5 = dr_lib.create_E_vs_Q_igs(
d_som4,
config.E_bins.toNessiList(),
config.Q_bins.toNessiList(),
so_id="Full Detector",
y_label="counts",
y_units="counts / (ueV * A^-1)",
x_labels=["Q transfer", "energy transfer"],
x_units=["1/Angstroms", "ueV"],
split=config.split,
Q_filter=False,
configure=config)
if tim is not None:
tim.getTime(msg="After creation of final spectrum ")
del d_som4
# Steps 33 to 36: Create S(-cos(polar), E)
elif config.ncospol_bins is not None:
if config.verbose:
print "Convert wavelength to energy transfer"
if tim is not None:
tim.getTime(False)
d_som4a = dr_lib.energy_transfer(d_som4,
"IGS",
"Wavelength_final",
sa_norm=True,
scale=True,
change_units=True)
if tim is not None:
tim.getTime(msg="After wavelength to energy transfer conversion ")
del d_som4
if config.verbose:
print "Creating 2D spectrum"
if tim is not None:
tim.getTime(False)
d_som5 = dr_lib.create_param_vs_Y(
d_som4a,
"polar",
"negcos_param_array",
config.ncospol_bins.toNessiList(),
rebin_axis=config.E_bins.toNessiList(),
y_label="counts",
y_units="counts / ueV",
x_labels=["-cos(polar)", "Energy Transfer"],
x_units=["", "ueV"])
if tim is not None:
tim.getTime(msg="After creation of final spectrum ")
# If rescaling factor present, rescale the data
if config.rescale_final is not None and not config.split:
d_som6 = common_lib.mult_ncerr(d_som5, (config.rescale_final, 0.0))
else:
d_som6 = d_som5
if tim is None:
old_time = None
if not __name__ == "amorphous_reduction_sqe":
del d_som5
__write_output(d_som6, config, tim, old_time)
else:
if config.create_output:
del d_som5
__write_output(d_som6, config, tim, old_time)
else:
return d_som6
def run(config):
"""
This method is where the processing is done.
@param config: Object containing the driver configuration information.
@type config: L{hlr_utils.Configure}
"""
if config.data is None:
raise RuntimeError("Need to pass a data filename to the driver "\
+"script.")
dst_type = hlr_utils.file_peeker(config.data[0])
if dst_type != "text/Dave2d":
raise TypeError("Only Dave2D ASCII files can be handled. Do not "\
+"know how to handle %s." % dst_type)
spectra = []
# Read in all data files
for datafile in config.data:
spectra.append(dr_lib.add_files([datafile], dst_type=dst_type,
Verbose=config.verbose))
# Sort spectra on slowest axis (Q for BSS files)
spectra.sort(lambda x, y: cmp(x[0].axis[0].val[0], y[0].axis[0].val[0]))
# Create placeholder for combined spectrum
Ny = len(spectra)
Nx = len(spectra[0][0].axis[1].val)
import nessi_list
import SOM
result = SOM.SOM()
result = hlr_utils.copy_som_attr(result, "SOM", spectra[0], "SOM")
so = SOM.SO(2)
so.id = 0
so.y = nessi_list.NessiList(Nx * Ny)
so.var_y = nessi_list.NessiList(Nx * Ny)
so.axis[1].val = spectra[0][0].axis[1].val
# Make the slowest axis
slow_axis = [x[0].axis[0].val[0] for x in spectra]
so.axis[0].val = nessi_list.NessiList()
so.axis[0].val.extend(slow_axis)
# Create combined spectrum
import array_manip
for i in xrange(Ny):
value = hlr_utils.get_value(spectra[i], 0, "SOM", "y")
err2 = hlr_utils.get_err2(spectra[i], 0, "SOM", "y")
start = i * Nx
(so.y, so.var_y) = array_manip.add_ncerr(so.y, so.var_y, value, err2,
a_start=start)
result.append(so)
# Rescale data if necessary
if config.rescale is not None:
import common_lib
result2 = common_lib.mult_ncerr(result, (config.rescale, 0.0))
else:
result2 = result
del result
hlr_utils.write_file(config.output, dst_type, result2,
verbose=config.verbose,
replace_ext=False,
path_replacement=config.path_replacement,
axis_ok=True,
message="combined file")
def run(config):
"""
This method is where the processing is done.
@param config: Object containing the driver configuration information.
@type config: L{hlr_utils.Configure}
"""
if config.data is None:
raise RuntimeError("Need to pass a data filename to the driver "\
+"script.")
dst_type = hlr_utils.file_peeker(config.data[0])
if dst_type != "text/Dave2d":
raise TypeError("Only Dave2D ASCII files can be handled. Do not "\
+"know how to handle %s." % dst_type)
spectra = []
# Read in all data files
for datafile in config.data:
spectra.append(
dr_lib.add_files([datafile],
dst_type=dst_type,
Verbose=config.verbose))
# Sort spectra on slowest axis (Q for BSS files)
spectra.sort(lambda x, y: cmp(x[0].axis[0].val[0], y[0].axis[0].val[0]))
# Create placeholder for combined spectrum
Ny = len(spectra)
Nx = len(spectra[0][0].axis[1].val)
import nessi_list
import SOM
result = SOM.SOM()
result = hlr_utils.copy_som_attr(result, "SOM", spectra[0], "SOM")
so = SOM.SO(2)
so.id = 0
so.y = nessi_list.NessiList(Nx * Ny)
so.var_y = nessi_list.NessiList(Nx * Ny)
so.axis[1].val = spectra[0][0].axis[1].val
# Make the slowest axis
slow_axis = [x[0].axis[0].val[0] for x in spectra]
so.axis[0].val = nessi_list.NessiList()
so.axis[0].val.extend(slow_axis)
# Create combined spectrum
import array_manip
for i in xrange(Ny):
value = hlr_utils.get_value(spectra[i], 0, "SOM", "y")
err2 = hlr_utils.get_err2(spectra[i], 0, "SOM", "y")
start = i * Nx
(so.y, so.var_y) = array_manip.add_ncerr(so.y,
so.var_y,
value,
err2,
a_start=start)
result.append(so)
# Rescale data if necessary
if config.rescale is not None:
import common_lib
result2 = common_lib.mult_ncerr(result, (config.rescale, 0.0))
else:
result2 = result
del result
hlr_utils.write_file(config.output,
dst_type,
result2,
verbose=config.verbose,
replace_ext=False,
path_replacement=config.path_replacement,
axis_ok=True,
message="combined file")
def process_igs_data(datalist, conf, **kwargs):
"""
This function combines Steps 1 through 8 of the data reduction process for
Inverse Geometry Spectrometers as specified by the documents at
U{http://neutrons.ornl.gov/asg/projects/SCL/reqspec/DR_Lib_RS.doc}. The
function takes a list of file names, a L{hlr_utils.Configure} object and
processes the data accordingly. This function should really only be used in
the context of I{amorphous_reduction} and I{calc_norm_eff}.
@param datalist: A list containing the filenames of the data to be
processed.
@type datalist: C{list} of C{string}s
@param conf: Object that contains the current setup of the driver.
@type conf: L{hlr_utils.Configure}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword inst_geom_dst: File object that contains instrument geometry
information.
@type inst_geom_dst: C{DST.GeomDST}
@keyword dataset_type: The practical name of the dataset being processed.
The default value is I{data}.
@type dataset_type: C{string}
@keyword tib_const: Object providing the time-independent background
constant to subtract.
@type tib_const: L{hlr_utils.DrParameter}
@keyword bkg_som: Object that will be used for early background subtraction
@type bkg_som: C{SOM.SOM}
@keyword timer: Timing object so the function can perform timing estimates.
@type timer: C{sns_timer.DiffTime}
@return: Object that has undergone all requested processing steps
@rtype: C{SOM.SOM}
"""
import hlr_utils
# Check keywords
try:
dataset_type = kwargs["dataset_type"]
except KeyError:
dataset_type = "data"
try:
t = kwargs["timer"]
except KeyError:
t = None
try:
if kwargs["tib_const"] is not None:
tib_const = kwargs["tib_const"].toValErrTuple()
else:
tib_const = None
except KeyError:
tib_const = None
try:
i_geom_dst = kwargs["inst_geom_dst"]
except KeyError:
i_geom_dst = None
try:
bkg_som = kwargs["bkg_som"]
except KeyError:
bkg_som = None
# Step 1: Open appropriate data files
if not conf.mc:
so_axis = "time_of_flight"
else:
so_axis = "Time_of_Flight"
# Add so_axis to Configure object
conf.so_axis = so_axis
if conf.verbose:
print "Reading %s file" % dataset_type
# Special case handling for normalization data. Dynamically trying to
# determine if incoming file is a previously calculated one.
if dataset_type == "normalization":
try:
# Check the first incoming file
dst_type = hlr_utils.file_peeker(datalist[0])
# If file_peeker succeeds, the DST is different than the function
# returns
dst_type = "text/num-info"
# Let ROI file handle filtering
data_paths = None
except RuntimeError:
# It's a NeXus file
dst_type = "application/x-NeXus"
data_paths = conf.data_paths.toPath()
else:
dst_type = "application/x-NeXus"
data_paths = conf.data_paths.toPath()
# The [0] is to get the data SOM and ignore the None background SOM
dp_som0 = dr_lib.add_files(
datalist,
Data_Paths=data_paths,
SO_Axis=so_axis,
Signal_ROI=conf.roi_file,
dataset_type=dataset_type,
dst_type=dst_type,
Verbose=conf.verbose,
Timer=t,
)
if t is not None:
t.getTime(msg="After reading %s " % dataset_type)
if dst_type == "text/num-info":
# Since we have a pre-calculated normalization dataset, set the flag
# and return the SOM now
conf.pre_norm = True
# Make the labels and units compatible with a NeXus file based SOM
dp_som0.setAxisLabel(0, "wavelength")
dp_som0.setAxisUnits(0, "Angstroms")
dp_som0.setYUnits("Counts/A")
return dp_som0
else:
if dataset_type == "normalization":
# Since we have a NeXus file, we need to continue
conf.pre_norm = False
# Cut the spectra if necessary
dp_somA = dr_lib.cut_spectra(dp_som0, conf.tof_cut_min, conf.tof_cut_max)
del dp_som0
dp_som1 = dr_lib.fix_bin_contents(dp_somA)
del dp_somA
if conf.inst_geom is not None:
i_geom_dst.setGeometry(conf.data_paths.toPath(), dp_som1)
if conf.no_mon_norm:
dm_som1 = None
else:
if conf.verbose:
print "Reading in monitor data from %s file" % dataset_type
# The [0] is to get the data SOM and ignore the None background SOM
dm_som0 = dr_lib.add_files(
datalist,
Data_Paths=conf.mon_path.toPath(),
SO_Axis=so_axis,
dataset_type=dataset_type,
Verbose=conf.verbose,
Timer=t,
)
if t is not None:
t.getTime(msg="After reading monitor data ")
dm_som1 = dr_lib.fix_bin_contents(dm_som0)
del dm_som0
if conf.inst_geom is not None:
i_geom_dst.setGeometry(conf.mon_path.toPath(), dm_som1)
if bkg_som is not None:
bkg_pcharge = bkg_som.attr_list["background-proton_charge"].getValue()
data_pcharge = dp_som1.attr_list[dataset_type + "-proton_charge"].getValue()
ratio = data_pcharge / bkg_pcharge
bkg_som1 = common_lib.mult_ncerr(bkg_som, (ratio, 0.0))
del bkg_som
dp_som2 = dr_lib.subtract_bkg_from_data(
dp_som1, bkg_som1, verbose=conf.verbose, timer=t, dataset1=dataset_type, dataset2="background"
)
else:
dp_som2 = dp_som1
del dp_som1
# Step 2: Dead Time Correction
# No dead time correction is being applied to the data yet
# Step 3: Time-independent background determination
if conf.verbose and conf.tib_tofs is not None:
print "Determining time-independent background from data"
if t is not None and conf.tib_tofs is not None:
t.getTime(False)
B = dr_lib.determine_time_indep_bkg(dp_som2, conf.tib_tofs)
if t is not None and B is not None:
t.getTime(msg="After determining time-independent background ")
if conf.dump_tib and B is not None:
file_comment = "TOFs: %s" % conf.tib_tofs
hlr_utils.write_file(
conf.output,
"text/num-info",
B,
output_ext="tib",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="time-independent background " + "information",
tag="Average",
units="counts",
comments=[file_comment],
)
# Step 4: Subtract time-independent background
if conf.verbose and B is not None:
print "Subtracting time-independent background from data"
if t is not None:
t.getTime(False)
if B is not None:
dp_som3 = common_lib.sub_ncerr(dp_som2, B)
else:
dp_som3 = dp_som2
if B is not None and t is not None:
t.getTime(msg="After subtracting time-independent background ")
del dp_som2, B
# Step 5: Subtract time-independent background constant
if conf.verbose and tib_const is not None:
print "Subtracting time-independent background constant from data"
if t is not None and tib_const is not None:
t.getTime(False)
if tib_const is not None:
dp_som4 = common_lib.sub_ncerr(dp_som3, tib_const)
else:
dp_som4 = dp_som3
if t is not None and tib_const is not None:
t.getTime(msg="After subtracting time-independent background " + "constant ")
del dp_som3
# Provide override capability for final wavelength, time-zero slope and
# time-zero offset
if conf.wavelength_final is not None:
dp_som4.attr_list["Wavelength_final"] = conf.wavelength_final.toValErrTuple()
# Note: time_zero_slope MUST be a tuple
if conf.time_zero_slope is not None:
dp_som4.attr_list["Time_zero_slope"] = conf.time_zero_slope.toValErrTuple()
if dm_som1 is not None:
dm_som1.attr_list["Time_zero_slope"] = conf.time_zero_slope.toValErrTuple()
# Note: time_zero_offset MUST be a tuple
if conf.time_zero_offset is not None:
dp_som4.attr_list["Time_zero_offset"] = conf.time_zero_offset.toValErrTuple()
if dm_som1 is not None:
dm_som1.attr_list["Time_zero_offset"] = conf.time_zero_offset.toValErrTuple()
# Step 6: Convert TOF to wavelength for data and monitor
if conf.verbose:
print "Converting TOF to wavelength"
if t is not None:
t.getTime(False)
# Convert monitor
if dm_som1 is not None:
dm_som2 = common_lib.tof_to_wavelength_lin_time_zero(dm_som1, units="microsecond")
else:
dm_som2 = None
# Convert detector pixels
dp_som5 = common_lib.tof_to_initial_wavelength_igs_lin_time_zero(
dp_som4, units="microsecond", run_filter=conf.filter
)
if t is not None:
t.getTime(msg="After converting TOF to wavelength ")
if conf.dump_wave:
hlr_utils.write_file(
conf.output,
"text/Spec",
dp_som5,
output_ext="pxl",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="pixel wavelength information",
)
if conf.dump_mon_wave and dm_som2 is not None:
hlr_utils.write_file(
conf.output,
"text/Spec",
dm_som2,
output_ext="mxl",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="monitor wavelength information",
)
del dp_som4, dm_som1
# Step 7: Efficiency correct monitor
if conf.verbose and dm_som2 is not None and not conf.no_mon_effc:
print "Efficiency correct monitor data"
if t is not None:
t.getTime(False)
if not conf.no_mon_effc:
dm_som3 = dr_lib.feff_correct_mon(dm_som2)
else:
dm_som3 = dm_som2
if t is not None and dm_som2 is not None and not conf.no_mon_effc:
t.getTime(msg="After efficiency correcting monitor ")
if conf.dump_mon_effc and not conf.no_mon_effc and dm_som3 is not None:
hlr_utils.write_file(
conf.output,
"text/Spec",
dm_som3,
output_ext="mel",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="monitor wavelength information " + "(efficiency)",
)
del dm_som2
# Step 8: Rebin monitor axis onto detector pixel axis
if conf.verbose and dm_som3 is not None:
print "Rebin monitor axis to detector pixel axis"
if t is not None:
t.getTime(False)
dm_som4 = dr_lib.rebin_monitor(dm_som3, dp_som5)
if t is not None and dm_som4 is not None:
t.getTime(msg="After rebinning monitor ")
del dm_som3
if conf.dump_mon_rebin and dm_som4 is not None:
hlr_utils.write_file(
conf.output,
"text/Spec",
dm_som4,
output_ext="mrl",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message="monitor wavelength information " + "(rebinned)",
)
# The lambda-dependent background is only done on sample data (aka data)
# for the BSS instrument at the SNS
if conf.inst == "BSS" and conf.ldb_const is not None and dataset_type == "data":
# Step 9: Convert chopper center wavelength to TOF center
if conf.verbose:
print "Converting chopper center wavelength to TOF"
if t is not None:
t.getTime(False)
tof_center = dr_lib.convert_single_to_list(
"initial_wavelength_igs_lin_time_zero_to_tof", conf.chopper_lambda_cent.toValErrTuple(), dp_som5
)
# Step 10: Calculate beginning and end of detector TOF spectrum
if conf.verbose:
print "Calculating beginning and ending TOF ranges"
half_inv_chop_freq = 0.5 / conf.chopper_freq.toValErrTuple()[0]
# Above is in seconds, need microseconds
half_inv_chop_freq *= 1.0e6
tof_begin = common_lib.sub_ncerr(tof_center, (half_inv_chop_freq, 0.0))
tof_end = common_lib.add_ncerr(tof_center, (half_inv_chop_freq, 0.0))
# Step 11: Convert TOF_begin and TOF_end to wavelength
if conf.verbose:
print "Converting TOF_begin and TOF_end to wavelength"
# Check for time-zero slope information
try:
tz_slope = conf.time_zero_slope.toValErrTuple()
except AttributeError:
tz_slope = (0.0, 0.0)
# Check for time-zero offset information
try:
tz_offset = conf.time_zero_offset.toValErrTuple()
except AttributeError:
tz_offset = (0.0, 0.0)
l_begin = common_lib.tof_to_initial_wavelength_igs_lin_time_zero(
tof_begin, time_zero_slope=tz_slope, time_zero_offset=tz_offset, iobj=dp_som5, run_filter=False
)
l_end = common_lib.tof_to_initial_wavelength_igs_lin_time_zero(
tof_end, time_zero_slope=tz_slope, time_zero_offset=tz_offset, iobj=dp_som5, run_filter=False
)
# Step 12: tof-least-bkg to lambda-least-bkg
if conf.verbose:
print "Converting TOF least background to wavelength"
lambda_least_bkg = dr_lib.convert_single_to_list(
"tof_to_initial_wavelength_igs_lin_time_zero", conf.tof_least_bkg.toValErrTuple(), dp_som5
)
if t is not None:
t.getTime(msg="After converting boundary positions ")
# Step 13: Create lambda-dependent background spectrum
if conf.verbose:
print "Creating lambda-dependent background spectra"
if t is not None:
t.getTime(False)
ldb_som = dr_lib.shift_spectrum(dm_som4, lambda_least_bkg, l_begin, l_end, conf.ldb_const.getValue())
if t is not None:
t.getTime(msg="After creating lambda-dependent background " + "spectra ")
# Step 14: Subtract lambda-dependent background from sample data
if conf.verbose:
print "Subtracting lambda-dependent background from data"
if t is not None:
t.getTime(False)
dp_som6 = common_lib.sub_ncerr(dp_som5, ldb_som)
if t is not None:
t.getTime(msg="After subtracting lambda-dependent background " + "from data ")
else:
dp_som6 = dp_som5
del dp_som5
# Step 15: Normalize data by monitor
if conf.verbose and dm_som4 is not None:
print "Normalizing data by monitor"
if t is not None:
t.getTime(False)
if dm_som4 is not None:
dp_som7 = common_lib.div_ncerr(dp_som6, dm_som4)
if t is not None:
t.getTime(msg="After normalizing data by monitor ")
else:
dp_som7 = dp_som6
if conf.dump_wave_mnorm:
dp_som7_1 = dr_lib.sum_all_spectra(dp_som7, rebin_axis=conf.lambda_bins.toNessiList())
write_message = "combined pixel wavelength information"
if dm_som4 is not None:
write_message += " (monitor normalized)"
hlr_utils.write_file(
conf.output,
"text/Spec",
dp_som7_1,
output_ext="pml",
extra_tag=dataset_type,
verbose=conf.verbose,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
message=write_message,
)
del dp_som7_1
del dm_som4, dp_som6
return dp_som7
def process_dgs_data(obj, conf, bcan, ecan, tcoeff, **kwargs):
"""
This function combines Steps 7 through 16 in Section 2.1.1 of the data
reduction process for Direct Geometry Spectrometers as specified by the
document at
U{http://neutrons.ornl.gov/asg/projects/SCL/reqspec/DR_Lib_RS.doc}. The
function takes a calibrated dataset, a L{hlr_utils.Configure} object and
processes the data accordingly.
@param obj: A calibrated dataset object.
@type obj: C{SOM.SOM}
@param conf: Object that contains the current setup of the driver.
@type conf: L{hlr_utils.Configure}
@param bcan: The object containing the black can data.
@type bcan: C{SOM.SOM}
@param ecan: The object containing the empty can data.
@type ecan: C{SOM.SOM}
@param tcoeff: The transmission coefficient appropriate to the given data
set.
@type tcoeff: C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword dataset_type: The practical name of the dataset being processed.
The default value is I{data}.
@type dataset_type: C{string}
@keyword cwp_used: A flag signalling the use of the chopper phase
corrections.
@type cwp_used: C{bool}
@keyword timer: Timing object so the function can perform timing estimates.
@type timer: C{sns_timer.DiffTime}
@return: Object that has undergone all requested processing steps
@rtype: C{SOM.SOM}
"""
import array_manip
import common_lib
import dr_lib
import hlr_utils
# Check keywords
try:
dataset_type = kwargs["dataset_type"]
except KeyError:
dataset_type = "data"
try:
t = kwargs["timer"]
except KeyError:
t = None
cwp_used = kwargs.get("cwp_used", False)
if conf.verbose:
print "Processing %s information" % dataset_type
# Step 7: Create black can background contribution
if bcan is not None:
if conf.verbose:
print "Creating black can background contribution for %s" \
% dataset_type
if t is not None:
t.getTime(False)
bccoeff = array_manip.sub_ncerr(1.0, 0.0, tcoeff[0], tcoeff[1])
bcan1 = common_lib.mult_ncerr(bcan, bccoeff)
if t is not None:
t.getTime(msg="After creating black can background contribution ")
del bcan
else:
bcan1 = None
# Step 8: Create empty can background contribution
if ecan is not None:
if conf.verbose:
print "Creating empty can background contribution for %s" \
% dataset_type
if t is not None:
t.getTime(False)
ecan1 = common_lib.mult_ncerr(ecan, tcoeff)
if t is not None:
t.getTime(msg="After creating empty can background contribution ")
del ecan
else:
ecan1 = None
# Step 9: Create background spectra
if bcan1 is not None or ecan1 is not None and conf.verbose:
print "Creating background spectra for %s" % dataset_type
if bcan1 is not None and ecan1 is not None:
if cwp_used:
if conf.verbose:
print "Rebinning empty can to black can axis."
ecan2 = common_lib.rebin_axis_1D_frac(ecan1, bcan1[0].axis[0].val)
else:
ecan2 = ecan1
del ecan1
if t is not None:
t.getTime(False)
b_som = common_lib.add_ncerr(bcan1, ecan2)
if t is not None:
t.getTime(msg="After creating background spectra ")
elif bcan1 is not None and ecan1 is None:
b_som = bcan1
elif bcan1 is None and ecan1 is not None:
b_som = ecan1
else:
b_som = None
del bcan1, ecan1
if cwp_used:
if conf.verbose:
print "Rebinning background spectra to %s" % dataset_type
b_som1 = common_lib.rebin_axis_1D_frac(b_som, obj[0].axis[0].val)
else:
b_som1 = b_som
del b_som
if conf.dump_ctof_comb and b_som1 is not None:
b_som_1 = dr_lib.sum_all_spectra(b_som1)
hlr_utils.write_file(conf.output, "text/Spec", b_som_1,
output_ext="ctof",
extra_tag="background",
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
verbose=conf.verbose,
message="combined background TOF information")
del b_som_1
# Step 10: Subtract background from data
obj1 = dr_lib.subtract_bkg_from_data(obj, b_som1, verbose=conf.verbose,
timer=t,
dataset1=dataset_type,
dataset2="background")
del obj, b_som1
# Step 11: Calculate initial velocity
if conf.verbose:
print "Calculating initial velocity"
if t is not None:
t.getTime(False)
if conf.initial_energy is not None:
initial_wavelength = common_lib.energy_to_wavelength(\
conf.initial_energy.toValErrTuple())
initial_velocity = common_lib.wavelength_to_velocity(\
initial_wavelength)
else:
# This should actually calculate it, but don't have a way right now
pass
if t is not None:
t.getTime(msg="After calculating initial velocity ")
# Step 12: Calculate the time-zero offset
if conf.time_zero_offset is not None:
time_zero_offset = conf.time_zero_offset.toValErrTuple()
else:
# This should actually calculate it, but don't have a way right now
time_zero_offset = (0.0, 0.0)
# Step 13: Convert time-of-flight to final velocity
if conf.verbose:
print "Converting TOF to final velocity DGS"
if t is not None:
t.getTime(False)
obj2 = common_lib.tof_to_final_velocity_dgs(obj1, initial_velocity,
time_zero_offset,
units="microsecond")
if t is not None:
t.getTime(msg="After calculating TOF to final velocity DGS ")
del obj1
# Step 14: Convert final velocity to final wavelength
if conf.verbose:
print "Converting final velocity DGS to final wavelength"
if t is not None:
t.getTime(False)
obj3 = common_lib.velocity_to_wavelength(obj2)
if t is not None:
t.getTime(msg="After calculating velocity to wavelength ")
del obj2
if conf.dump_wave_comb:
obj3_1 = dr_lib.sum_all_spectra(obj3,
rebin_axis=conf.lambda_bins.toNessiList())
hlr_utils.write_file(conf.output, "text/Spec", obj3_1,
output_ext="fwv",
extra_tag=dataset_type,
data_ext=conf.ext_replacement,
path_replacement=conf.path_replacement,
verbose=conf.verbose,
message="combined final wavelength information")
del obj3_1
# Step 15: Create the detector efficiency
if conf.det_eff is not None:
if conf.verbose:
print "Creating detector efficiency spectra"
if t is not None:
t.getTime(False)
det_eff = dr_lib.create_det_eff(obj3)
if t is not None:
t.getTime(msg="After creating detector efficiency spectra ")
else:
det_eff = None
# Step 16: Divide the detector pixel spectra by the detector efficiency
if det_eff is not None:
if conf.verbose:
print "Correcting %s for detector efficiency" % dataset_type
if t is not None:
t.getTime(False)
obj4 = common_lib.div_ncerr(obj3, det_eff)
if t is not None:
t.getTime(msg="After correcting %s for detector efficiency" \
% dataset_type)
else:
obj4 = obj3
del obj3, det_eff
return obj4