def tof_to_scalar_Q(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to scalarQ. The time-of-flight axis for a C{SOM} must be in
units of I{microseconds}. The primary axis of a C{SO} is assumed to be in
units of I{microseconds}. A C{tuple} of C{(time-of-flight,
time-of-flight_err2)} (assumed to be in units of I{microseconds}) can be
converted to C{(scalar_Q, scalar_Q_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword polar: The polar angle and its associated error^2
@type polar: C{tuple} or C{list} of C{tuple}s
@keyword pathlength: The pathlength and its associated error^2
@type pathlength: C{tuple} or C{list} of C{tuple}s
@keyword angle_offset: A constant offset for the polar angle and its
associated error^2. The units of the offset should
be in radians.
@type angle_offset: C{tuple}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}.
@type units: C{string}
@return: Object with a primary axis in time-of-flight converted to scalar Q
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: A C{SOM} is not passed and no polar angle is provided
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
if o_descr == "list":
raise TypeError("Do not know how to handle given type: %s" % \
o_descr)
else:
pass
# Setup keyword arguments
try:
polar = kwargs["polar"]
except KeyError:
polar = None
try:
pathlength = kwargs["pathlength"]
except KeyError:
pathlength = None
try:
units = kwargs["units"]
except KeyError:
units = "microseconds"
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
try:
angle_offset = kwargs["angle_offset"]
except KeyError:
angle_offset = None
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "1/Angstroms", axis)
result.setAxisLabel(axis, "scalar wavevector transfer")
result.setYUnits("Counts/A-1")
result.setYLabel("Intensity")
else:
pass
if pathlength is None or polar is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided")
else:
if pathlength is None and polar is None:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"and polar angle information must be "\
+"provided")
elif pathlength is None:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"information must be provided")
elif polar is None:
raise RuntimeError("If no SOM is provided, then polar angle "\
+"information must be provided")
else:
raise RuntimeError("If you get here, see Steve Miller for "\
+"your mug.")
else:
pass
if pathlength is not None:
p_descr = hlr_utils.get_descr(pathlength)
else:
pass
if polar is not None:
a_descr = hlr_utils.get_descr(polar)
else:
pass
# iterate through the values
import axis_manip
if lojac:
import utils
for i in xrange(hlr_utils.get_length(obj)):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if pathlength is None:
(pl, pl_err2) = hlr_utils.get_parameter("total", map_so, inst)
else:
pl = hlr_utils.get_value(pathlength, i, p_descr)
pl_err2 = hlr_utils.get_err2(pathlength, i, p_descr)
if polar is None:
(angle,
angle_err2) = hlr_utils.get_parameter("polar", map_so, inst)
else:
angle = hlr_utils.get_value(polar, i, a_descr)
angle_err2 = hlr_utils.get_err2(polar, i, a_descr)
if angle_offset is not None:
angle += angle_offset[0]
angle_err2 += angle_offset[1]
value = axis_manip.tof_to_scalar_Q(val, err2, pl, pl_err2, angle,
angle_err2)
if lojac:
y_val = hlr_utils.get_value(obj, i, o_descr, "y")
y_err2 = hlr_utils.get_err2(obj, i, o_descr, "y")
counts = utils.linear_order_jacobian(val, value[0], y_val, y_err2)
else:
pass
if o_descr != "number":
value1 = axis_manip.reverse_array_cp(value[0])
value2 = axis_manip.reverse_array_cp(value[1])
rev_value = (value1, value2)
else:
rev_value = value
if map_so is not None:
if not lojac:
map_so.y = axis_manip.reverse_array_cp(map_so.y)
map_so.var_y = axis_manip.reverse_array_cp(map_so.var_y)
else:
map_so.y = axis_manip.reverse_array_cp(counts[0])
map_so.var_y = axis_manip.reverse_array_cp(counts[1])
else:
pass
hlr_utils.result_insert(result, res_descr, rev_value, map_so, "x",
axis)
return result
def wavelength_to_velocity(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from wavelength
to velocity. The wavelength axis for a C{SOM} must be in units of
I{Angstroms}. The primary axis of a C{SO} is assumed to be in
units of I{Angstroms}. A C{tuple} of C{(wavelength, wavelength_err2)}
(assumed to be in units of I{Angstroms}) can be converted to
C{(velocity, velocity_err)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{Angstroms}
@type units: C{string}
@return: Object with a primary axis in wavelength converted to velocity
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{Angstroms}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
if o_descr == "list":
raise TypeError("Do not know how to handle given type: %s" % \
o_descr)
else:
pass
# Setup keyword arguments
try:
units = kwargs["units"]
except KeyError:
units = "Angstroms"
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "meters/microseconds", axis)
result.setAxisLabel(axis, "velocity")
result.setYUnits("Counts/meters/microseconds")
result.setYLabel("Intensity")
else:
pass
# iterate through the values
import axis_manip
if lojac:
import utils
len_obj = hlr_utils.get_length(obj)
for i in xrange(len_obj):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
value = axis_manip.wavelength_to_velocity(val, err2)
if lojac:
y_val = hlr_utils.get_value(obj, i, o_descr, "y")
y_err2 = hlr_utils.get_err2(obj, i, o_descr, "y")
counts = utils.linear_order_jacobian(val, value[0], y_val, y_err2)
else:
pass
if o_descr != "number":
value1 = axis_manip.reverse_array_cp(value[0])
value2 = axis_manip.reverse_array_cp(value[1])
rev_value = (value1, value2)
else:
rev_value = value
if map_so is not None:
if not lojac:
map_so.y = axis_manip.reverse_array_cp(map_so.y)
map_so.var_y = axis_manip.reverse_array_cp(map_so.var_y)
else:
map_so.y = axis_manip.reverse_array_cp(counts[0])
map_so.var_y = axis_manip.reverse_array_cp(counts[1])
else:
pass
hlr_utils.result_insert(result, res_descr, rev_value, map_so, "x",
axis)
return result
def wavelength_to_velocity(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from wavelength
to velocity. The wavelength axis for a C{SOM} must be in units of
I{Angstroms}. The primary axis of a C{SO} is assumed to be in
units of I{Angstroms}. A C{tuple} of C{(wavelength, wavelength_err2)}
(assumed to be in units of I{Angstroms}) can be converted to
C{(velocity, velocity_err)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{Angstroms}
@type units: C{string}
@return: Object with a primary axis in wavelength converted to velocity
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{Angstroms}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
if o_descr == "list":
raise TypeError("Do not know how to handle given type: %s" % \
o_descr)
else:
pass
# Setup keyword arguments
try:
units = kwargs["units"]
except KeyError:
units = "Angstroms"
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "meters/microseconds", axis)
result.setAxisLabel(axis, "velocity")
result.setYUnits("Counts/meters/microseconds")
result.setYLabel("Intensity")
else:
pass
# iterate through the values
import axis_manip
if lojac:
import utils
len_obj = hlr_utils.get_length(obj)
for i in xrange(len_obj):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
value = axis_manip.wavelength_to_velocity(val, err2)
if lojac:
y_val = hlr_utils.get_value(obj, i, o_descr, "y")
y_err2 = hlr_utils.get_err2(obj, i, o_descr, "y")
counts = utils.linear_order_jacobian(val, value[0],
y_val, y_err2)
else:
pass
if o_descr != "number":
value1 = axis_manip.reverse_array_cp(value[0])
value2 = axis_manip.reverse_array_cp(value[1])
rev_value = (value1, value2)
else:
rev_value = value
if map_so is not None:
if not lojac:
map_so.y = axis_manip.reverse_array_cp(map_so.y)
map_so.var_y = axis_manip.reverse_array_cp(map_so.var_y)
else:
map_so.y = axis_manip.reverse_array_cp(counts[0])
map_so.var_y = axis_manip.reverse_array_cp(counts[1])
else:
pass
hlr_utils.result_insert(result, res_descr, rev_value, map_so, "x",
axis)
return result
def tof_to_wavelength_lin_time_zero(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to wavelength incorporating a linear time zero which is a
described as a linear function of the wavelength. The time-of-flight axis
for a C{SOM} must be in units of I{microseconds}. The primary axis of a
C{SO} is assumed to be in units of I{microseconds}. A C{tuple} of C{(tof,
tof_err2)} (assumed to be in units of I{microseconds}) can be converted to
C{(wavelength, wavelength_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword pathlength: The pathlength and its associated error^2
@type pathlength: C{tuple} or C{list} of C{tuple}s
@keyword time_zero_slope: The time zero slope and its associated error^2
@type time_zero_slope: C{tuple}
@keyword time_zero_offset: The time zero offset and its associated error^2
@type time_zero_offset: C{tuple}
@keyword inst_param: The type of parameter requested from an associated
instrument. For this function the acceptable
parameters are I{primary}, I{secondary} and I{total}.
Default is I{primary}.
@type inst_param: C{string}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is I{True} for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}.
@type units: C{string}
@keyword cut_val: Specify a wavelength to cut the spectra at.
@type cut_val: C{float}
@keyword cut_less: A flag that specifies cutting the spectra less than
C{cut_val}. The default is C{True}.
@type cut_less: C{boolean}
@return: Object with a primary axis in time-of-flight converted to
wavelength
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
@raise RuntimeError: A C{SOM} does not contain an instrument and no
pathlength was provided
@raise RuntimeError: No C{SOM} is provided and no pathlength given
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
inst_param = kwargs["inst_param"]
except KeyError:
inst_param = "primary"
try:
pathlength = kwargs["pathlength"]
except KeyError:
pathlength = None
try:
time_zero_slope = kwargs["time_zero_slope"]
except KeyError:
time_zero_slope = None
# Current constants for Time Zero Slope
TIME_ZERO_SLOPE = (float(0.0), float(0.0))
try:
time_zero_offset = kwargs["time_zero_offset"]
except KeyError:
time_zero_offset = None
# Current constants for Time Zero Offset
TIME_ZERO_OFFSET = (float(0.0), float(0.0))
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
try:
units = kwargs["units"]
except KeyError:
units = "microseconds"
try:
cut_val = kwargs["cut_val"]
except KeyError:
cut_val = None
try:
cut_less = kwargs["cut_less"]
except KeyError:
cut_less = True
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "Angstroms", axis)
result.setAxisLabel(axis, "wavelength")
result.setYUnits("Counts/A")
result.setYLabel("Intensity")
else:
pass
if pathlength is not None:
p_descr = hlr_utils.get_descr(pathlength)
else:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided")
else:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"information must be provided")
if time_zero_slope is not None:
t_0_slope_descr = hlr_utils.get_descr(time_zero_slope)
else:
if o_descr == "SOM":
try:
t_0_slope = obj.attr_list["Time_zero_slope"][0]
t_0_slope_err2 = obj.attr_list["Time_zero_slope"][1]
except KeyError:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
else:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
if time_zero_offset is not None:
t_0_offset_descr = hlr_utils.get_descr(time_zero_offset)
else:
if o_descr == "SOM":
try:
t_0_offset = obj.attr_list["Time_zero_offset"][0]
t_0_offset_err2 = obj.attr_list["Time_zero_offset"][1]
except KeyError:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
else:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
# iterate through the values
import axis_manip
if lojac or cut_val is not None:
import utils
for i in xrange(hlr_utils.get_length(obj)):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if pathlength is None:
(pl, pl_err2) = hlr_utils.get_parameter(inst_param, map_so, inst)
else:
pl = hlr_utils.get_value(pathlength, i, p_descr)
pl_err2 = hlr_utils.get_err2(pathlength, i, p_descr)
if time_zero_slope is not None:
t_0_slope = hlr_utils.get_value(time_zero_slope, i,
t_0_slope_descr)
t_0_slope_err2 = hlr_utils.get_err2(time_zero_slope, i,
t_0_slope_descr)
else:
pass
if time_zero_offset is not None:
t_0_offset = hlr_utils.get_value(time_zero_offset, i,
t_0_offset_descr)
t_0_offset_err2 = hlr_utils.get_err2(time_zero_offset, i,
t_0_offset_descr)
else:
pass
value = axis_manip.tof_to_wavelength_lin_time_zero(
val, err2, pl, pl_err2, t_0_slope, t_0_slope_err2, t_0_offset,
t_0_offset_err2)
if cut_val is not None:
index = utils.bisect_helper(value[0], cut_val)
if cut_less:
# Need to cut at this index, so increment by one
index += 1
value[0].__delslice__(0, index)
value[1].__delslice__(0, index)
map_so.y.__delslice__(0, index)
map_so.var_y.__delslice__(0, index)
if lojac:
val.__delslice__(0, index)
err2.__delslice__(0, index)
else:
len_data = len(value[0])
# All axis arrays need starting index adjusted by one since
# they always carry one more bin than the data
value[0].__delslice__(index + 1, len_data)
value[1].__delslice__(index + 1, len_data)
map_so.y.__delslice__(index, len_data)
map_so.var_y.__delslice__(index, len_data)
if lojac:
val.__delslice__(index + 1, len_data)
err2.__delslice__(index + 1, len_data)
if lojac:
counts = utils.linear_order_jacobian(val, value[0], map_so.y,
map_so.var_y)
hlr_utils.result_insert(result, res_descr, counts, map_so, "all",
axis, [value[0]])
else:
hlr_utils.result_insert(result, res_descr, value, map_so, "x",
axis)
return result
def tof_to_wavelength(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to wavelength. The wavelength axis for a C{SOM} must be in
units of I{microseconds}. The primary axis of a C{SO} is assumed to be in
units of I{microseconds}. A C{tuple} of C{(tof, tof_err2)} (assumed to be
in units of I{microseconds}) can be converted to C{(wavelength,
wavelength_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword pathlength: The pathlength and its associated error^2
@type pathlength: C{tuple} or C{list} of C{tuple}s
@keyword inst_param: The type of parameter requested from an associated
instrument. For this function the acceptable
parameters are I{primary}, I{secondary} and I{total}.
Default is I{primary}.
@type inst_param: C{string}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is I{True} for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}.
@type units: C{string}
@return: Object with a primary axis in time-of-flight converted to
wavelength
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
@raise RuntimeError: A C{SOM} does not contain an instrument and no
pathlength was provided
@raise RuntimeError: No C{SOM} is provided and no pathlength given
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
inst_param = kwargs["inst_param"]
except KeyError:
inst_param = "primary"
try:
pathlength = kwargs["pathlength"]
except KeyError:
pathlength = None
try:
units = kwargs["units"]
except KeyError:
units = "microseconds"
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "Angstroms", axis)
result.setAxisLabel(axis, "wavelength")
result.setYUnits("Counts/A")
result.setYLabel("Intensity")
else:
pass
if pathlength is not None:
p_descr = hlr_utils.get_descr(pathlength)
else:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided")
else:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"information must be provided")
# iterate through the values
import axis_manip
if lojac:
import utils
for i in xrange(hlr_utils.get_length(obj)):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if pathlength is None:
(pl, pl_err2) = hlr_utils.get_parameter(inst_param, map_so, inst)
else:
pl = hlr_utils.get_value(pathlength, i, p_descr)
pl_err2 = hlr_utils.get_err2(pathlength, i, p_descr)
value = axis_manip.tof_to_wavelength(val, err2, pl, pl_err2)
if lojac:
y_val = hlr_utils.get_value(obj, i, o_descr, "y")
y_err2 = hlr_utils.get_err2(obj, i, o_descr, "y")
counts = utils.linear_order_jacobian(val, value[0],
y_val, y_err2)
hlr_utils.result_insert(result, res_descr, counts, map_so,
"all", axis, [value[0]])
else:
hlr_utils.result_insert(result, res_descr, value, map_so,
"x", axis)
return result
def initial_wavelength_igs_lin_time_zero_to_tof(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
initial_wavelength_igs_lin_time_zero to time-of-flight. The
initial_wavelength_igs_lin_time_zero axis for a C{SOM} must be in units of
I{Angstroms}. The primary axis of a C{SO} is assumed to be in units of
I{Angstroms}. A C{tuple} of C{(initial_wavelength_igs_lin_time_zero,
initial_wavelength_igs_lin_time_zero_err2)} (assumed to be in units of
I{Angstroms}) can be converted to C{(tof, tof_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword lambda_f:The final wavelength and its associated error^2
@type lambda_f: C{tuple}
@keyword time_zero_slope: The time zero slope and its associated error^2
@type time_zero_slope: C{tuple}
@keyword time_zero_offset: The time zero offset and its associated error^2
@type time_zero_offset: C{tuple}
@keyword dist_source_sample: The source to sample distance information and
its associated error^2
@type dist_source_sample: C{tuple} or C{list} of C{tuple}s
@keyword dist_sample_detector: The sample to detector distance information
and its associated error^2
@type dist_sample_detector: C{tuple} or C{list} of C{tuple}s
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{Angstroms}
@type units: C{string}
@return: Object with a primary axis in initial_wavelength_igs converted to
time-of-flight
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{Angstroms}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
lambda_f = kwargs["lambda_f"]
except KeyError:
lambda_f = None
try:
time_zero_slope = kwargs["time_zero_slope"]
except KeyError:
time_zero_slope = None
# Current constants for Time Zero Slope
TIME_ZERO_SLOPE = (float(0.0), float(0.0))
try:
time_zero_offset = kwargs["time_zero_offset"]
except KeyError:
time_zero_offset = None
# Current constants for Time Zero Offset
TIME_ZERO_OFFSET = (float(0.0), float(0.0))
try:
dist_source_sample = kwargs["dist_source_sample"]
except KeyError:
dist_source_sample = None
try:
dist_sample_detector = kwargs["dist_sample_detector"]
except KeyError:
dist_sample_detector = None
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
try:
units = kwargs["units"]
except KeyError:
units = "Angstroms"
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "Microseconds", axis)
result.setAxisLabel(axis, "time-of-flight")
result.setYUnits("Counts/uS")
result.setYLabel("Intensity")
else:
pass
# Where to get instrument information
if dist_source_sample is None or dist_sample_detector is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided!")
else:
if dist_source_sample is None and dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample and sample-detector "\
+"distances must be provided.")
elif dist_source_sample is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample distance must be provided.")
elif dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"sample-detector distance must be "\
+"provided.")
else:
raise RuntimeError("If you get here, see Steve Miller for "\
+"your mug.")
else:
pass
if lambda_f is not None:
l_descr = hlr_utils.get_descr(lambda_f)
else:
if o_descr == "SOM":
try:
som_l_f = obj.attr_list["Wavelength_final"]
except KeyError:
raise RuntimeError("Please provide a final wavelength "\
+"parameter either via the function call "\
+"or the SOM")
else:
raise RuntimeError("You need to provide a final wavelength")
if time_zero_slope is not None:
t_0_slope_descr = hlr_utils.get_descr(time_zero_slope)
else:
if o_descr == "SOM":
try:
t_0_slope = obj.attr_list["Time_zero_slope"][0]
t_0_slope_err2 = obj.attr_list["Time_zero_slope"][1]
except KeyError:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
else:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
if time_zero_offset is not None:
t_0_offset_descr = hlr_utils.get_descr(time_zero_offset)
else:
if o_descr == "SOM":
try:
t_0_offset = obj.attr_list["Time_zero_offset"][0]
t_0_offset_err2 = obj.attr_list["Time_zero_offset"][1]
except KeyError:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
else:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
if dist_source_sample is not None:
ls_descr = hlr_utils.get_descr(dist_source_sample)
# Do nothing, go on
else:
pass
if dist_sample_detector is not None:
ld_descr = hlr_utils.get_descr(dist_sample_detector)
# Do nothing, go on
else:
pass
# iterate through the values
len_obj = hlr_utils.get_length(obj)
MNEUT_OVER_H = 1.0 / 0.003956034
MNEUT_OVER_H2 = MNEUT_OVER_H * MNEUT_OVER_H
for i in xrange(len_obj):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if dist_source_sample is None:
(L_s, L_s_err2) = hlr_utils.get_parameter("primary", map_so, inst)
else:
L_s = hlr_utils.get_value(dist_source_sample, i, ls_descr)
L_s_err2 = hlr_utils.get_err2(dist_source_sample, i, ls_descr)
if dist_sample_detector is None:
(L_d, L_d_err2) = hlr_utils.get_parameter("secondary", map_so,
inst)
else:
L_d = hlr_utils.get_value(dist_sample_detector, i, ld_descr)
L_d_err2 = hlr_utils.get_err2(dist_sample_detector, i, ld_descr)
if lambda_f is not None:
l_f = hlr_utils.get_value(lambda_f, i, l_descr)
l_f_err2 = hlr_utils.get_err2(lambda_f, i, l_descr)
else:
l_f_tuple = hlr_utils.get_special(som_l_f, map_so)
l_f = l_f_tuple[0]
l_f_err2 = l_f_tuple[1]
if time_zero_slope is not None:
t_0_slope = hlr_utils.get_value(time_zero_slope, i,
t_0_slope_descr)
t_0_slope_err2 = hlr_utils.get_err2(time_zero_slope, i,
t_0_slope_descr)
else:
pass
if time_zero_offset is not None:
t_0_offset = hlr_utils.get_value(time_zero_offset, i,
t_0_offset_descr)
t_0_offset_err2 = hlr_utils.get_err2(time_zero_offset, i,
t_0_offset_descr)
else:
pass
# Going to violate rules since the current usage is with a single
# number. When an SCL equivalent function arises, this code can be
# fixed.
front_const = MNEUT_OVER_H * L_s + t_0_slope
term2 = MNEUT_OVER_H * l_f * L_d
tof = (front_const * val) + term2 + t_0_offset
front_const2 = front_const * front_const
eterm1 = l_f * l_f * L_d_err2
eterm2 = L_d * L_d * l_f_err2
eterm3 = MNEUT_OVER_H2 * L_s_err2
tof_err2 = (front_const2 * err2) + (val * val) * \
(eterm3 + t_0_slope_err2) + (MNEUT_OVER_H2 * \
(eterm1 + eterm2)) + \
t_0_offset_err2
hlr_utils.result_insert(result, res_descr, (tof, tof_err2), None,
"all")
return result
def tof_to_wavelength_lin_time_zero(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to wavelength incorporating a linear time zero which is a
described as a linear function of the wavelength. The time-of-flight axis
for a C{SOM} must be in units of I{microseconds}. The primary axis of a
C{SO} is assumed to be in units of I{microseconds}. A C{tuple} of C{(tof,
tof_err2)} (assumed to be in units of I{microseconds}) can be converted to
C{(wavelength, wavelength_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword pathlength: The pathlength and its associated error^2
@type pathlength: C{tuple} or C{list} of C{tuple}s
@keyword time_zero_slope: The time zero slope and its associated error^2
@type time_zero_slope: C{tuple}
@keyword time_zero_offset: The time zero offset and its associated error^2
@type time_zero_offset: C{tuple}
@keyword inst_param: The type of parameter requested from an associated
instrument. For this function the acceptable
parameters are I{primary}, I{secondary} and I{total}.
Default is I{primary}.
@type inst_param: C{string}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is I{True} for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}.
@type units: C{string}
@keyword cut_val: Specify a wavelength to cut the spectra at.
@type cut_val: C{float}
@keyword cut_less: A flag that specifies cutting the spectra less than
C{cut_val}. The default is C{True}.
@type cut_less: C{boolean}
@return: Object with a primary axis in time-of-flight converted to
wavelength
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
@raise RuntimeError: A C{SOM} does not contain an instrument and no
pathlength was provided
@raise RuntimeError: No C{SOM} is provided and no pathlength given
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
inst_param = kwargs["inst_param"]
except KeyError:
inst_param = "primary"
try:
pathlength = kwargs["pathlength"]
except KeyError:
pathlength = None
try:
time_zero_slope = kwargs["time_zero_slope"]
except KeyError:
time_zero_slope = None
# Current constants for Time Zero Slope
TIME_ZERO_SLOPE = (float(0.0), float(0.0))
try:
time_zero_offset = kwargs["time_zero_offset"]
except KeyError:
time_zero_offset = None
# Current constants for Time Zero Offset
TIME_ZERO_OFFSET = (float(0.0), float(0.0))
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
try:
units = kwargs["units"]
except KeyError:
units = "microseconds"
try:
cut_val = kwargs["cut_val"]
except KeyError:
cut_val = None
try:
cut_less = kwargs["cut_less"]
except KeyError:
cut_less = True
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "Angstroms", axis)
result.setAxisLabel(axis, "wavelength")
result.setYUnits("Counts/A")
result.setYLabel("Intensity")
else:
pass
if pathlength is not None:
p_descr = hlr_utils.get_descr(pathlength)
else:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided")
else:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"information must be provided")
if time_zero_slope is not None:
t_0_slope_descr = hlr_utils.get_descr(time_zero_slope)
else:
if o_descr == "SOM":
try:
t_0_slope = obj.attr_list["Time_zero_slope"][0]
t_0_slope_err2 = obj.attr_list["Time_zero_slope"][1]
except KeyError:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
else:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
if time_zero_offset is not None:
t_0_offset_descr = hlr_utils.get_descr(time_zero_offset)
else:
if o_descr == "SOM":
try:
t_0_offset = obj.attr_list["Time_zero_offset"][0]
t_0_offset_err2 = obj.attr_list["Time_zero_offset"][1]
except KeyError:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
else:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
# iterate through the values
import axis_manip
if lojac or cut_val is not None:
import utils
for i in xrange(hlr_utils.get_length(obj)):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if pathlength is None:
(pl, pl_err2) = hlr_utils.get_parameter(inst_param, map_so, inst)
else:
pl = hlr_utils.get_value(pathlength, i, p_descr)
pl_err2 = hlr_utils.get_err2(pathlength, i, p_descr)
if time_zero_slope is not None:
t_0_slope = hlr_utils.get_value(time_zero_slope, i,
t_0_slope_descr)
t_0_slope_err2 = hlr_utils.get_err2(time_zero_slope, i,
t_0_slope_descr)
else:
pass
if time_zero_offset is not None:
t_0_offset = hlr_utils.get_value(time_zero_offset, i,
t_0_offset_descr)
t_0_offset_err2 = hlr_utils.get_err2(time_zero_offset, i,
t_0_offset_descr)
else:
pass
value = axis_manip.tof_to_wavelength_lin_time_zero(val, err2,
pl, pl_err2,
t_0_slope,
t_0_slope_err2,
t_0_offset,
t_0_offset_err2)
if cut_val is not None:
index = utils.bisect_helper(value[0], cut_val)
if cut_less:
# Need to cut at this index, so increment by one
index += 1
value[0].__delslice__(0, index)
value[1].__delslice__(0, index)
map_so.y.__delslice__(0, index)
map_so.var_y.__delslice__(0, index)
if lojac:
val.__delslice__(0, index)
err2.__delslice__(0, index)
else:
len_data = len(value[0])
# All axis arrays need starting index adjusted by one since
# they always carry one more bin than the data
value[0].__delslice__(index + 1, len_data)
value[1].__delslice__(index + 1, len_data)
map_so.y.__delslice__(index, len_data)
map_so.var_y.__delslice__(index, len_data)
if lojac:
val.__delslice__(index + 1, len_data)
err2.__delslice__(index + 1, len_data)
if lojac:
counts = utils.linear_order_jacobian(val, value[0],
map_so.y, map_so.var_y)
hlr_utils.result_insert(result, res_descr, counts, map_so,
"all", axis, [value[0]])
else:
hlr_utils.result_insert(result, res_descr, value, map_so,
"x", axis)
return result
def tof_to_ref_scalar_Q(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to reflectometer scalar Q. This means that a single angle
and a single flightpath is used. The time-of-flight axis for a C{SOM} must
be in units of I{microseconds}. The primary axis of a C{SO} is assumed to
be in units of I{microseconds}. A C{tuple} of C{(time-of-flight,
time-of-flight_err2)} (assumed to be in units of I{microseconds}) can be
converted to C{(scalar_Q, scalar_Q_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword polar: The polar angle and its associated error^2
@type polar: C{tuple}
@keyword pathlength: The pathlength and its associated error^2
@type pathlength: C{tuple}
@keyword angle_offset: A constant offset for the polar angle and its
associated error^2. The units of the offset should
be in radians.
@type angle_offset: C{tuple}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}.
@type units: C{string}
@keyword configure: This is the object containing the driver configuration.
This will signal the function to write out the counts
and fractional area to files.
@type configure: C{Configure}
@return: Object with a primary axis in time-of-flight converted to
reflectometer scalar Q
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: A C{SOM} is not passed and no polar angle is provided
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
if o_descr == "list":
raise TypeError("Do not know how to handle given type: %s" % \
o_descr)
else:
pass
# Setup keyword arguments
polar = kwargs.get("polar")
pathlength = kwargs.get("pathlength")
units = kwargs.get("units", "microseconds")
lojac = kwargs.get("lojac", hlr_utils.check_lojac(obj))
angle_offset = kwargs.get("angle_offset")
config = kwargs.get("configure")
if config is None:
beamdiv_corr = False
else:
beamdiv_corr = config.beamdiv_corr
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "1/Angstroms", axis)
result.setAxisLabel(axis, "scalar wavevector transfer")
result.setYUnits("Counts/A-1")
result.setYLabel("Intensity")
else:
pass
if pathlength is None or polar is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided")
else:
if pathlength is None and polar is None:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"and polar angle information must be "\
+"provided")
elif pathlength is None:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"information must be provided")
elif polar is None:
raise RuntimeError("If no SOM is provided, then polar angle "\
+"information must be provided")
else:
raise RuntimeError("If you get here, see Steve Miller for "\
+"your mug.")
else:
pass
if pathlength is None:
(pl,
pl_err2) = obj.attr_list.instrument.get_total_path(obj[0].id,
det_secondary=True)
else:
(pl, pl_err2) = pathlength
if polar is None:
angle = hlr_utils.get_special(obj.attr_list["data-theta"], obj[0])[0]
angle_err2 = 0.0
else:
(angle, angle_err2) = polar
if angle_offset is not None:
angle += angle_offset[0]
angle_err2 += angle_offset[1]
# Need to multiply angle by 2.0 in order to make it be Theta to
# underlying conversion function
angle *= 2.0
angle_err2 *= 4.0
# iterate through the values
import axis_manip
if lojac:
import utils
if beamdiv_corr:
import dr_lib
for i in xrange(hlr_utils.get_length(obj)):
skip_pixel = False
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if beamdiv_corr:
dangle = dr_lib.ref_beamdiv_correct(obj.attr_list, map_so.id,
config.det_spat_res,
config.center_pix)
# We subtract due to the inversion of the z coordinates from the
# mirror reflection of the beam at the sample.
if dangle is not None:
pangle = angle - (2.0 * dangle)
else:
pangle = angle
skip_pixel = True
else:
pangle = angle
value = axis_manip.tof_to_scalar_Q(val, err2, pl, pl_err2, pangle,
angle_err2)
if lojac:
y_val = hlr_utils.get_value(obj, i, o_descr, "y")
y_err2 = hlr_utils.get_err2(obj, i, o_descr, "y")
counts = utils.linear_order_jacobian(val, value[0], y_val, y_err2)
else:
pass
if o_descr != "number":
value1 = axis_manip.reverse_array_cp(value[0])
value2 = axis_manip.reverse_array_cp(value[1])
rev_value = (value1, value2)
else:
rev_value = value
if map_so is not None:
if not lojac:
map_so.y = axis_manip.reverse_array_cp(map_so.y)
map_so.var_y = axis_manip.reverse_array_cp(map_so.var_y)
else:
map_so.y = axis_manip.reverse_array_cp(counts[0])
map_so.var_y = axis_manip.reverse_array_cp(counts[1])
else:
pass
if not skip_pixel:
hlr_utils.result_insert(result, res_descr, rev_value, map_so, "x",
axis)
return result
def tof_to_initial_wavelength_igs_lin_time_zero(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to initial_wavelength_igs_lin_time_zero. The time-of-flight
axis for a C{SOM} must be in units of I{microseconds}. The primary axis of
a C{SO} is assumed to be in units of I{microseconds}. A C{tuple} of
C{(tof, tof_err2)} (assumed to be in units of I{microseconds}) can be
converted to C{(initial_wavelength_igs, initial_wavelength_igs_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword lambda_f:The final wavelength and its associated error^2
@type lambda_f: C{tuple}
@keyword time_zero_slope: The time zero slope and its associated error^2
@type time_zero_slope: C{tuple}
@keyword time_zero_offset: The time zero offset and its associated error^2
@type time_zero_offset: C{tuple}
@keyword dist_source_sample: The source to sample distance information and
its associated error^2
@type dist_source_sample: C{tuple} or C{list} of C{tuple}s
@keyword dist_sample_detector: The sample to detector distance information
and its associated error^2
@type dist_sample_detector: C{tuple} or C{list} of C{tuple}s
@keyword run_filter: This determines if the filter on the negative
wavelengths is run. The default setting is True.
@type run_filter: C{boolean}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}
@type units: C{string}
@return: Object with a primary axis in time-of-flight converted to
initial_wavelength_igs
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
lambda_f = kwargs["lambda_f"]
except KeyError:
lambda_f = None
try:
time_zero_slope = kwargs["time_zero_slope"]
except KeyError:
time_zero_slope = None
# Current constants for Time Zero Slope
TIME_ZERO_SLOPE = (float(0.0), float(0.0))
try:
time_zero_offset = kwargs["time_zero_offset"]
except KeyError:
time_zero_offset = None
# Current constants for Time Zero Offset
TIME_ZERO_OFFSET = (float(0.0), float(0.0))
try:
dist_source_sample = kwargs["dist_source_sample"]
except KeyError:
dist_source_sample = None
try:
dist_sample_detector = kwargs["dist_sample_detector"]
except KeyError:
dist_sample_detector = None
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
try:
units = kwargs["units"]
except KeyError:
units = "microseconds"
try:
run_filter = kwargs["run_filter"]
except KeyError:
run_filter = True
try:
iobj = kwargs["iobj"]
except KeyError:
iobj = None
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "Angstroms", axis)
result.setAxisLabel(axis, "wavelength")
result.setYUnits("Counts/A")
result.setYLabel("Intensity")
else:
pass
# Where to get instrument information
if dist_source_sample is None or dist_sample_detector is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
mobj = obj
except RuntimeError:
raise RuntimeError("A detector was not provided!")
else:
if iobj is None:
if dist_source_sample is None and dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample and sample-detector "\
+"distances must be provided.")
elif dist_source_sample is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample distance must be "\
+"provided.")
elif dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"sample-detector distance must be "\
+"provided.")
else:
raise RuntimeError("If you get here, see Steve Miller "\
+"for your mug.")
else:
inst = iobj.attr_list.instrument
mobj = iobj
else:
mobj = obj
if lambda_f is not None:
l_descr = hlr_utils.get_descr(lambda_f)
else:
if o_descr == "SOM":
try:
som_l_f = obj.attr_list["Wavelength_final"]
except KeyError:
raise RuntimeError("Please provide a final wavelength "\
+"parameter either via the function call "\
+"or the SOM")
else:
if iobj is None:
raise RuntimeError("You need to provide a final wavelength")
else:
som_l_f = iobj.attr_list["Wavelength_final"]
if time_zero_slope is not None:
t_0_slope_descr = hlr_utils.get_descr(time_zero_slope)
else:
if o_descr == "SOM":
try:
t_0_slope = obj.attr_list["Time_zero_slope"][0]
t_0_slope_err2 = obj.attr_list["Time_zero_slope"][1]
except KeyError:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
else:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
if time_zero_offset is not None:
t_0_offset_descr = hlr_utils.get_descr(time_zero_offset)
else:
if o_descr == "SOM":
try:
t_0_offset = obj.attr_list["Time_zero_offset"][0]
t_0_offset_err2 = obj.attr_list["Time_zero_offset"][1]
except KeyError:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
else:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
if dist_source_sample is not None:
ls_descr = hlr_utils.get_descr(dist_source_sample)
# Do nothing, go on
else:
pass
if dist_sample_detector is not None:
ld_descr = hlr_utils.get_descr(dist_sample_detector)
# Do nothing, go on
else:
pass
# iterate through the values
import axis_manip
if lojac:
import utils
for i in xrange(hlr_utils.get_length(obj)):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(mobj, None, i)
if dist_source_sample is None:
(L_s, L_s_err2) = hlr_utils.get_parameter("primary", map_so, inst)
else:
L_s = hlr_utils.get_value(dist_source_sample, i, ls_descr)
L_s_err2 = hlr_utils.get_err2(dist_source_sample, i, ls_descr)
if dist_sample_detector is None:
(L_d, L_d_err2) = hlr_utils.get_parameter("secondary", map_so,
inst)
else:
L_d = hlr_utils.get_value(dist_sample_detector, i, ld_descr)
L_d_err2 = hlr_utils.get_err2(dist_sample_detector, i, ld_descr)
if lambda_f is not None:
l_f = hlr_utils.get_value(lambda_f, i, l_descr)
l_f_err2 = hlr_utils.get_err2(lambda_f, i, l_descr)
else:
l_f_tuple = hlr_utils.get_special(som_l_f, map_so)
l_f = l_f_tuple[0]
l_f_err2 = l_f_tuple[1]
if time_zero_slope is not None:
t_0_slope = hlr_utils.get_value(time_zero_slope, i,
t_0_slope_descr)
t_0_slope_err2 = hlr_utils.get_err2(time_zero_slope, i,
t_0_slope_descr)
else:
pass
if time_zero_offset is not None:
t_0_offset = hlr_utils.get_value(time_zero_offset, i,
t_0_offset_descr)
t_0_offset_err2 = hlr_utils.get_err2(time_zero_offset, i,
t_0_offset_descr)
else:
pass
value = axis_manip.tof_to_initial_wavelength_igs_lin_time_zero(
val, err2, l_f, l_f_err2, t_0_slope, t_0_slope_err2, t_0_offset,
t_0_offset_err2, L_s, L_s_err2, L_d, L_d_err2)
# Remove all wavelengths < 0
if run_filter:
index = 0
for valx in value[0]:
if valx >= 0:
break
index += 1
value[0].__delslice__(0, index)
value[1].__delslice__(0, index)
map_so.y.__delslice__(0, index)
map_so.var_y.__delslice__(0, index)
if lojac:
val.__delslice__(0, index)
err2.__delslice__(0, index)
else:
pass
if lojac:
try:
counts = utils.linear_order_jacobian(val, value[0], map_so.y,
map_so.var_y)
except Exception, e:
# Lets us know offending pixel ID
raise Exception(str(map_so.id) + " " + str(e))
hlr_utils.result_insert(result, res_descr, counts, map_so, "all",
axis, [value[0]])
else:
hlr_utils.result_insert(result, res_descr, value, map_so, "x",
axis)
def tof_to_ref_scalar_Q(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to reflectometer scalar Q. This means that a single angle
and a single flightpath is used. The time-of-flight axis for a C{SOM} must
be in units of I{microseconds}. The primary axis of a C{SO} is assumed to
be in units of I{microseconds}. A C{tuple} of C{(time-of-flight,
time-of-flight_err2)} (assumed to be in units of I{microseconds}) can be
converted to C{(scalar_Q, scalar_Q_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword polar: The polar angle and its associated error^2
@type polar: C{tuple}
@keyword pathlength: The pathlength and its associated error^2
@type pathlength: C{tuple}
@keyword angle_offset: A constant offset for the polar angle and its
associated error^2. The units of the offset should
be in radians.
@type angle_offset: C{tuple}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}.
@type units: C{string}
@keyword configure: This is the object containing the driver configuration.
This will signal the function to write out the counts
and fractional area to files.
@type configure: C{Configure}
@return: Object with a primary axis in time-of-flight converted to
reflectometer scalar Q
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: A C{SOM} is not passed and no polar angle is provided
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
if o_descr == "list":
raise TypeError("Do not know how to handle given type: %s" % \
o_descr)
else:
pass
# Setup keyword arguments
polar = kwargs.get("polar")
pathlength = kwargs.get("pathlength")
units = kwargs.get("units", "microseconds")
lojac = kwargs.get("lojac", hlr_utils.check_lojac(obj))
angle_offset = kwargs.get("angle_offset")
config = kwargs.get("configure")
if config is None:
beamdiv_corr = False
else:
beamdiv_corr = config.beamdiv_corr
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "1/Angstroms", axis)
result.setAxisLabel(axis, "scalar wavevector transfer")
result.setYUnits("Counts/A-1")
result.setYLabel("Intensity")
else:
pass
if pathlength is None or polar is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided")
else:
if pathlength is None and polar is None:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"and polar angle information must be "\
+"provided")
elif pathlength is None:
raise RuntimeError("If no SOM is provided, then pathlength "\
+"information must be provided")
elif polar is None:
raise RuntimeError("If no SOM is provided, then polar angle "\
+"information must be provided")
else:
raise RuntimeError("If you get here, see Steve Miller for "\
+"your mug.")
else:
pass
if pathlength is None:
(pl, pl_err2) = obj.attr_list.instrument.get_total_path(obj[0].id,
det_secondary=True)
else:
(pl, pl_err2) = pathlength
if polar is None:
angle = hlr_utils.get_special(obj.attr_list["data-theta"], obj[0])[0]
angle_err2 = 0.0
else:
(angle, angle_err2) = polar
if angle_offset is not None:
angle += angle_offset[0]
angle_err2 += angle_offset[1]
# Need to multiply angle by 2.0 in order to make it be Theta to
# underlying conversion function
angle *= 2.0
angle_err2 *= 4.0
# iterate through the values
import axis_manip
if lojac:
import utils
if beamdiv_corr:
import dr_lib
for i in xrange(hlr_utils.get_length(obj)):
skip_pixel = False
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if beamdiv_corr:
dangle = dr_lib.ref_beamdiv_correct(obj.attr_list, map_so.id,
config.det_spat_res,
config.center_pix)
# We subtract due to the inversion of the z coordinates from the
# mirror reflection of the beam at the sample.
if dangle is not None:
pangle = angle - (2.0 * dangle)
else:
pangle = angle
skip_pixel = True
else:
pangle = angle
value = axis_manip.tof_to_scalar_Q(val, err2, pl, pl_err2, pangle,
angle_err2)
if lojac:
y_val = hlr_utils.get_value(obj, i, o_descr, "y")
y_err2 = hlr_utils.get_err2(obj, i, o_descr, "y")
counts = utils.linear_order_jacobian(val, value[0],
y_val, y_err2)
else:
pass
if o_descr != "number":
value1 = axis_manip.reverse_array_cp(value[0])
value2 = axis_manip.reverse_array_cp(value[1])
rev_value = (value1, value2)
else:
rev_value = value
if map_so is not None:
if not lojac:
map_so.y = axis_manip.reverse_array_cp(map_so.y)
map_so.var_y = axis_manip.reverse_array_cp(map_so.var_y)
else:
map_so.y = axis_manip.reverse_array_cp(counts[0])
map_so.var_y = axis_manip.reverse_array_cp(counts[1])
else:
pass
if not skip_pixel:
hlr_utils.result_insert(result, res_descr, rev_value, map_so, "x",
axis)
return result
def initial_wavelength_igs_lin_time_zero_to_tof(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
initial_wavelength_igs_lin_time_zero to time-of-flight. The
initial_wavelength_igs_lin_time_zero axis for a C{SOM} must be in units of
I{Angstroms}. The primary axis of a C{SO} is assumed to be in units of
I{Angstroms}. A C{tuple} of C{(initial_wavelength_igs_lin_time_zero,
initial_wavelength_igs_lin_time_zero_err2)} (assumed to be in units of
I{Angstroms}) can be converted to C{(tof, tof_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword lambda_f:The final wavelength and its associated error^2
@type lambda_f: C{tuple}
@keyword time_zero_slope: The time zero slope and its associated error^2
@type time_zero_slope: C{tuple}
@keyword time_zero_offset: The time zero offset and its associated error^2
@type time_zero_offset: C{tuple}
@keyword dist_source_sample: The source to sample distance information and
its associated error^2
@type dist_source_sample: C{tuple} or C{list} of C{tuple}s
@keyword dist_sample_detector: The sample to detector distance information
and its associated error^2
@type dist_sample_detector: C{tuple} or C{list} of C{tuple}s
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{Angstroms}
@type units: C{string}
@return: Object with a primary axis in initial_wavelength_igs converted to
time-of-flight
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{Angstroms}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
lambda_f = kwargs["lambda_f"]
except KeyError:
lambda_f = None
try:
time_zero_slope = kwargs["time_zero_slope"]
except KeyError:
time_zero_slope = None
# Current constants for Time Zero Slope
TIME_ZERO_SLOPE = (float(0.0), float(0.0))
try:
time_zero_offset = kwargs["time_zero_offset"]
except KeyError:
time_zero_offset = None
# Current constants for Time Zero Offset
TIME_ZERO_OFFSET = (float(0.0), float(0.0))
try:
dist_source_sample = kwargs["dist_source_sample"]
except KeyError:
dist_source_sample = None
try:
dist_sample_detector = kwargs["dist_sample_detector"]
except KeyError:
dist_sample_detector = None
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
try:
units = kwargs["units"]
except KeyError:
units = "Angstroms"
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "Microseconds", axis)
result.setAxisLabel(axis, "time-of-flight")
result.setYUnits("Counts/uS")
result.setYLabel("Intensity")
else:
pass
# Where to get instrument information
if dist_source_sample is None or dist_sample_detector is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided!")
else:
if dist_source_sample is None and dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample and sample-detector "\
+"distances must be provided.")
elif dist_source_sample is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample distance must be provided.")
elif dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"sample-detector distance must be "\
+"provided.")
else:
raise RuntimeError("If you get here, see Steve Miller for "\
+"your mug.")
else:
pass
if lambda_f is not None:
l_descr = hlr_utils.get_descr(lambda_f)
else:
if o_descr == "SOM":
try:
som_l_f = obj.attr_list["Wavelength_final"]
except KeyError:
raise RuntimeError("Please provide a final wavelength "\
+"parameter either via the function call "\
+"or the SOM")
else:
raise RuntimeError("You need to provide a final wavelength")
if time_zero_slope is not None:
t_0_slope_descr = hlr_utils.get_descr(time_zero_slope)
else:
if o_descr == "SOM":
try:
t_0_slope = obj.attr_list["Time_zero_slope"][0]
t_0_slope_err2 = obj.attr_list["Time_zero_slope"][1]
except KeyError:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
else:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
if time_zero_offset is not None:
t_0_offset_descr = hlr_utils.get_descr(time_zero_offset)
else:
if o_descr == "SOM":
try:
t_0_offset = obj.attr_list["Time_zero_offset"][0]
t_0_offset_err2 = obj.attr_list["Time_zero_offset"][1]
except KeyError:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
else:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
if dist_source_sample is not None:
ls_descr = hlr_utils.get_descr(dist_source_sample)
# Do nothing, go on
else:
pass
if dist_sample_detector is not None:
ld_descr = hlr_utils.get_descr(dist_sample_detector)
# Do nothing, go on
else:
pass
# iterate through the values
len_obj = hlr_utils.get_length(obj)
MNEUT_OVER_H = 1.0 / 0.003956034
MNEUT_OVER_H2 = MNEUT_OVER_H * MNEUT_OVER_H
for i in xrange(len_obj):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if dist_source_sample is None:
(L_s, L_s_err2) = hlr_utils.get_parameter("primary", map_so, inst)
else:
L_s = hlr_utils.get_value(dist_source_sample, i, ls_descr)
L_s_err2 = hlr_utils.get_err2(dist_source_sample, i, ls_descr)
if dist_sample_detector is None:
(L_d, L_d_err2) = hlr_utils.get_parameter("secondary", map_so,
inst)
else:
L_d = hlr_utils.get_value(dist_sample_detector, i, ld_descr)
L_d_err2 = hlr_utils.get_err2(dist_sample_detector, i, ld_descr)
if lambda_f is not None:
l_f = hlr_utils.get_value(lambda_f, i, l_descr)
l_f_err2 = hlr_utils.get_err2(lambda_f, i, l_descr)
else:
l_f_tuple = hlr_utils.get_special(som_l_f, map_so)
l_f = l_f_tuple[0]
l_f_err2 = l_f_tuple[1]
if time_zero_slope is not None:
t_0_slope = hlr_utils.get_value(time_zero_slope, i,
t_0_slope_descr)
t_0_slope_err2 = hlr_utils.get_err2(time_zero_slope, i,
t_0_slope_descr)
else:
pass
if time_zero_offset is not None:
t_0_offset = hlr_utils.get_value(time_zero_offset, i,
t_0_offset_descr)
t_0_offset_err2 = hlr_utils.get_err2(time_zero_offset, i,
t_0_offset_descr)
else:
pass
# Going to violate rules since the current usage is with a single
# number. When an SCL equivalent function arises, this code can be
# fixed.
front_const = MNEUT_OVER_H * L_s + t_0_slope
term2 = MNEUT_OVER_H * l_f * L_d
tof = (front_const * val) + term2 + t_0_offset
front_const2 = front_const * front_const
eterm1 = l_f * l_f * L_d_err2
eterm2 = L_d * L_d * l_f_err2
eterm3 = MNEUT_OVER_H2 * L_s_err2
tof_err2 = (front_const2 * err2) + (val * val) * \
(eterm3 + t_0_slope_err2) + (MNEUT_OVER_H2 * \
(eterm1 + eterm2)) + \
t_0_offset_err2
hlr_utils.result_insert(result, res_descr, (tof, tof_err2), None,
"all")
return result
def wavelength_to_scalar_Q(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from wavelength
to scalar Q. The wavelength axis for a C{SOM} must be in units of
I{Angstroms}. The primary axis of a C{SO} is assumed to be in units of
I{Angstroms}. A C{tuple} of C{(wavelength, wavelength_err2)} (assumed to
be in units of I{Angstroms}) can be converted to C{(scalar_Q,
scalar_Q_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword polar: The polar angle and its associated error^2
@type polar: C{tuple} or C{list} of C{tuple}s
@keyword pathlength: The pathlength and its associated error^2
@type pathlength: C{tuple} or C{list} of C{tuple}s
@keyword units: The expected units for this function. The default for this
function is I{Angstroms}.
@type units: C{string}
@return: Object with a primary axis in wavelength converted to scalar Q
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: A C{SOM} is not passed and no polar angle is provided
@raise RuntimeError: The C{SOM} x-axis units are not I{Angstroms}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
if o_descr == "list":
raise TypeError("Do not know how to handle given type: %s" % \
o_descr)
else:
pass
# Setup keyword arguments
try:
polar = kwargs["polar"]
except KeyError:
polar = None
try:
units = kwargs["units"]
except KeyError:
units = "Angstroms"
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "1/Angstroms", axis)
result.setAxisLabel(axis, "scalar wavevector transfer")
result.setYUnits("Counts/A-1")
result.setYLabel("Intensity")
else:
pass
if polar is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided!")
else:
raise RuntimeError("If no SOM is provided, then polar "\
+"information must be given.")
else:
p_descr = hlr_utils.get_descr(polar)
# iterate through the values
import axis_manip
if lojac:
import utils
for i in xrange(hlr_utils.get_length(obj)):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if polar is None:
(angle, angle_err2) = hlr_utils.get_parameter("polar", map_so,
inst)
else:
angle = hlr_utils.get_value(polar, i, p_descr)
angle_err2 = hlr_utils.get_err2(polar, i, p_descr)
value = axis_manip.wavelength_to_scalar_Q(val, err2, angle, angle_err2)
if lojac:
y_val = hlr_utils.get_value(obj, i, o_descr, "y")
y_err2 = hlr_utils.get_err2(obj, i, o_descr, "y")
counts = utils.linear_order_jacobian(val, value[0],
y_val, y_err2)
else:
pass
if o_descr != "number":
value1 = axis_manip.reverse_array_cp(value[0])
value2 = axis_manip.reverse_array_cp(value[1])
rev_value = (value1, value2)
else:
rev_value = value
if map_so is not None:
if not lojac:
map_so.y = axis_manip.reverse_array_cp(map_so.y)
map_so.var_y = axis_manip.reverse_array_cp(map_so.var_y)
else:
map_so.y = axis_manip.reverse_array_cp(counts[0])
map_so.var_y = axis_manip.reverse_array_cp(counts[1])
else:
pass
hlr_utils.result_insert(result, res_descr, rev_value, map_so, "x",
axis)
return result
def tof_to_final_velocity_dgs(obj, velocity_i, time_zero_offset, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to final_velocity_dgs. The time-of-flight axis for a
C{SOM} must be in units of I{microseconds}. The primary axis of a C{SO} is
assumed to be in units of I{microseconds}. A C{tuple} of C{(tof, tof_err2)}
(assumed to be in units of I{microseconds}) can be converted to
C{(final_velocity_dgs, final_velocity_dgs_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param velocity_i: The initial velocity and its associated error^2
@type velocity_i: C{tuple}
@param time_zero_offset: The time zero offset and its associated error^2
@type time_zero_offset: C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword dist_source_sample: The source to sample distance information and
its associated error^2
@type dist_source_sample: C{tuple} or C{list} of C{tuple}s
@keyword dist_sample_detector: The sample to detector distance information
and its associated error^2
@type dist_sample_detector: C{tuple} or C{list} of C{tuple}s
@keyword run_filter: This determines if the filter on the negative
velocities is run. The default setting is True.
@type run_filter: C{boolean}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}
@type units: C{string}
@return: Object with a primary axis in time-of-flight converted to
final_velocity_dgs
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
"""
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
dist_source_sample = kwargs["dist_source_sample"]
except KeyError:
dist_source_sample = None
try:
dist_sample_detector = kwargs["dist_sample_detector"]
except KeyError:
dist_sample_detector = None
try:
units = kwargs["units"]
except KeyError:
units = "microseconds"
try:
run_filter = kwargs["run_filter"]
except KeyError:
run_filter = True
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "meters/microseconds", axis)
result.setAxisLabel(axis, "velocity")
result.setYUnits("Counts/meters/microseconds")
result.setYLabel("Intensity")
else:
pass
# Where to get instrument information
if dist_source_sample is None or dist_sample_detector is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided!")
else:
if dist_source_sample is None and dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample and sample-detector "\
+"distances must be provided.")
elif dist_source_sample is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample distance must be provided.")
elif dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"sample-detector distance must be "\
+"provided.")
else:
raise RuntimeError("If you get here, see Steve Miller for "\
+"your mug.")
else:
pass
if dist_source_sample is not None:
ls_descr = hlr_utils.get_descr(dist_source_sample)
# Do nothing, go on
else:
pass
if dist_sample_detector is not None:
ld_descr = hlr_utils.get_descr(dist_sample_detector)
# Do nothing, go on
else:
pass
# iterate through the values
import axis_manip
if lojac:
import utils
len_obj = hlr_utils.get_length(obj)
for i in xrange(len_obj):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if dist_source_sample is None:
(L_s, L_s_err2) = hlr_utils.get_parameter("primary", map_so, inst)
else:
L_s = hlr_utils.get_value(dist_source_sample, i, ls_descr)
L_s_err2 = hlr_utils.get_err2(dist_source_sample, i, ls_descr)
if dist_sample_detector is None:
(L_d, L_d_err2) = hlr_utils.get_parameter("secondary", map_so,
inst)
else:
L_d = hlr_utils.get_value(dist_sample_detector, i, ld_descr)
L_d_err2 = hlr_utils.get_err2(dist_sample_detector, i, ld_descr)
value = axis_manip.tof_to_final_velocity_dgs(val, err2, velocity_i[0],
velocity_i[1],
time_zero_offset[0],
time_zero_offset[1], L_s,
L_s_err2, L_d, L_d_err2)
# Remove all velocities < 0
if run_filter:
index = 0
for valx in value[0]:
if valx >= 0:
break
index += 1
value[0].__delslice__(0, index)
value[1].__delslice__(0, index)
map_so.y.__delslice__(0, index)
map_so.var_y.__delslice__(0, index)
if lojac:
val.__delslice__(0, index)
err2.__delslice__(0, index)
else:
pass
if lojac:
(map_so.y, map_so.var_y) = utils.linear_order_jacobian(
val, value[0], map_so.y, map_so.var_y)
# Need to reverse arrays due to conversion
if o_descr != "number":
valx = axis_manip.reverse_array_cp(value[0])
valxe = axis_manip.reverse_array_cp(value[1])
rev_value = (valx, valxe)
else:
rev_value = value
if map_so is not None:
map_so.y = axis_manip.reverse_array_cp(map_so.y)
map_so.var_y = axis_manip.reverse_array_cp(map_so.var_y)
hlr_utils.result_insert(result, res_descr, rev_value, map_so, "x",
axis)
return result
def tof_to_final_velocity_dgs(obj, velocity_i, time_zero_offset, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to final_velocity_dgs. The time-of-flight axis for a
C{SOM} must be in units of I{microseconds}. The primary axis of a C{SO} is
assumed to be in units of I{microseconds}. A C{tuple} of C{(tof, tof_err2)}
(assumed to be in units of I{microseconds}) can be converted to
C{(final_velocity_dgs, final_velocity_dgs_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param velocity_i: The initial velocity and its associated error^2
@type velocity_i: C{tuple}
@param time_zero_offset: The time zero offset and its associated error^2
@type time_zero_offset: C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword dist_source_sample: The source to sample distance information and
its associated error^2
@type dist_source_sample: C{tuple} or C{list} of C{tuple}s
@keyword dist_sample_detector: The sample to detector distance information
and its associated error^2
@type dist_sample_detector: C{tuple} or C{list} of C{tuple}s
@keyword run_filter: This determines if the filter on the negative
velocities is run. The default setting is True.
@type run_filter: C{boolean}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}
@type units: C{string}
@return: Object with a primary axis in time-of-flight converted to
final_velocity_dgs
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
"""
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
dist_source_sample = kwargs["dist_source_sample"]
except KeyError:
dist_source_sample = None
try:
dist_sample_detector = kwargs["dist_sample_detector"]
except KeyError:
dist_sample_detector = None
try:
units = kwargs["units"]
except KeyError:
units = "microseconds"
try:
run_filter = kwargs["run_filter"]
except KeyError:
run_filter = True
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "meters/microseconds", axis)
result.setAxisLabel(axis, "velocity")
result.setYUnits("Counts/meters/microseconds")
result.setYLabel("Intensity")
else:
pass
# Where to get instrument information
if dist_source_sample is None or dist_sample_detector is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
except RuntimeError:
raise RuntimeError("A detector was not provided!")
else:
if dist_source_sample is None and dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample and sample-detector "\
+"distances must be provided.")
elif dist_source_sample is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample distance must be provided.")
elif dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"sample-detector distance must be "\
+"provided.")
else:
raise RuntimeError("If you get here, see Steve Miller for "\
+"your mug.")
else:
pass
if dist_source_sample is not None:
ls_descr = hlr_utils.get_descr(dist_source_sample)
# Do nothing, go on
else:
pass
if dist_sample_detector is not None:
ld_descr = hlr_utils.get_descr(dist_sample_detector)
# Do nothing, go on
else:
pass
# iterate through the values
import axis_manip
if lojac:
import utils
len_obj = hlr_utils.get_length(obj)
for i in xrange(len_obj):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(obj, None, i)
if dist_source_sample is None:
(L_s, L_s_err2) = hlr_utils.get_parameter("primary", map_so, inst)
else:
L_s = hlr_utils.get_value(dist_source_sample, i, ls_descr)
L_s_err2 = hlr_utils.get_err2(dist_source_sample, i, ls_descr)
if dist_sample_detector is None:
(L_d, L_d_err2) = hlr_utils.get_parameter("secondary", map_so,
inst)
else:
L_d = hlr_utils.get_value(dist_sample_detector, i, ld_descr)
L_d_err2 = hlr_utils.get_err2(dist_sample_detector, i, ld_descr)
value = axis_manip.tof_to_final_velocity_dgs(val, err2,
velocity_i[0],
velocity_i[1],
time_zero_offset[0],
time_zero_offset[1],
L_s, L_s_err2,
L_d, L_d_err2)
# Remove all velocities < 0
if run_filter:
index = 0
for valx in value[0]:
if valx >= 0:
break
index += 1
value[0].__delslice__(0, index)
value[1].__delslice__(0, index)
map_so.y.__delslice__(0, index)
map_so.var_y.__delslice__(0, index)
if lojac:
val.__delslice__(0, index)
err2.__delslice__(0, index)
else:
pass
if lojac:
(map_so.y,
map_so.var_y) = utils.linear_order_jacobian(val,
value[0],
map_so.y,
map_so.var_y)
# Need to reverse arrays due to conversion
if o_descr != "number":
valx = axis_manip.reverse_array_cp(value[0])
valxe = axis_manip.reverse_array_cp(value[1])
rev_value = (valx, valxe)
else:
rev_value = value
if map_so is not None:
map_so.y = axis_manip.reverse_array_cp(map_so.y)
map_so.var_y = axis_manip.reverse_array_cp(map_so.var_y)
hlr_utils.result_insert(result, res_descr, rev_value, map_so,
"x", axis)
return result
def tof_to_initial_wavelength_igs_lin_time_zero(obj, **kwargs):
"""
This function converts a primary axis of a C{SOM} or C{SO} from
time-of-flight to initial_wavelength_igs_lin_time_zero. The time-of-flight
axis for a C{SOM} must be in units of I{microseconds}. The primary axis of
a C{SO} is assumed to be in units of I{microseconds}. A C{tuple} of
C{(tof, tof_err2)} (assumed to be in units of I{microseconds}) can be
converted to C{(initial_wavelength_igs, initial_wavelength_igs_err2)}.
@param obj: Object to be converted
@type obj: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword lambda_f:The final wavelength and its associated error^2
@type lambda_f: C{tuple}
@keyword time_zero_slope: The time zero slope and its associated error^2
@type time_zero_slope: C{tuple}
@keyword time_zero_offset: The time zero offset and its associated error^2
@type time_zero_offset: C{tuple}
@keyword dist_source_sample: The source to sample distance information and
its associated error^2
@type dist_source_sample: C{tuple} or C{list} of C{tuple}s
@keyword dist_sample_detector: The sample to detector distance information
and its associated error^2
@type dist_sample_detector: C{tuple} or C{list} of C{tuple}s
@keyword run_filter: This determines if the filter on the negative
wavelengths is run. The default setting is True.
@type run_filter: C{boolean}
@keyword lojac: A flag that allows one to turn off the calculation of the
linear-order Jacobian. The default action is True for
histogram data.
@type lojac: C{boolean}
@keyword units: The expected units for this function. The default for this
function is I{microseconds}
@type units: C{string}
@return: Object with a primary axis in time-of-flight converted to
initial_wavelength_igs
@rtype: C{SOM.SOM}, C{SOM.SO} or C{tuple}
@raise TypeError: The incoming object is not a type the function recognizes
@raise RuntimeError: The C{SOM} x-axis units are not I{microseconds}
"""
# import the helper functions
import hlr_utils
# set up for working through data
(result, res_descr) = hlr_utils.empty_result(obj)
o_descr = hlr_utils.get_descr(obj)
# Setup keyword arguments
try:
lambda_f = kwargs["lambda_f"]
except KeyError:
lambda_f = None
try:
time_zero_slope = kwargs["time_zero_slope"]
except KeyError:
time_zero_slope = None
# Current constants for Time Zero Slope
TIME_ZERO_SLOPE = (float(0.0), float(0.0))
try:
time_zero_offset = kwargs["time_zero_offset"]
except KeyError:
time_zero_offset = None
# Current constants for Time Zero Offset
TIME_ZERO_OFFSET = (float(0.0), float(0.0))
try:
dist_source_sample = kwargs["dist_source_sample"]
except KeyError:
dist_source_sample = None
try:
dist_sample_detector = kwargs["dist_sample_detector"]
except KeyError:
dist_sample_detector = None
try:
lojac = kwargs["lojac"]
except KeyError:
lojac = hlr_utils.check_lojac(obj)
try:
units = kwargs["units"]
except KeyError:
units = "microseconds"
try:
run_filter = kwargs["run_filter"]
except KeyError:
run_filter = True
try:
iobj = kwargs["iobj"]
except KeyError:
iobj = None
# Primary axis for transformation. If a SO is passed, the function, will
# assume the axis for transformation is at the 0 position
if o_descr == "SOM":
axis = hlr_utils.one_d_units(obj, units)
else:
axis = 0
result = hlr_utils.copy_som_attr(result, res_descr, obj, o_descr)
if res_descr == "SOM":
result = hlr_utils.force_units(result, "Angstroms", axis)
result.setAxisLabel(axis, "wavelength")
result.setYUnits("Counts/A")
result.setYLabel("Intensity")
else:
pass
# Where to get instrument information
if dist_source_sample is None or dist_sample_detector is None:
if o_descr == "SOM":
try:
obj.attr_list.instrument.get_primary()
inst = obj.attr_list.instrument
mobj = obj
except RuntimeError:
raise RuntimeError("A detector was not provided!")
else:
if iobj is None:
if dist_source_sample is None and dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample and sample-detector "\
+"distances must be provided.")
elif dist_source_sample is None:
raise RuntimeError("If a SOM is not passed, the "\
+"source-sample distance must be "\
+"provided.")
elif dist_sample_detector is None:
raise RuntimeError("If a SOM is not passed, the "\
+"sample-detector distance must be "\
+"provided.")
else:
raise RuntimeError("If you get here, see Steve Miller "\
+"for your mug.")
else:
inst = iobj.attr_list.instrument
mobj = iobj
else:
mobj = obj
if lambda_f is not None:
l_descr = hlr_utils.get_descr(lambda_f)
else:
if o_descr == "SOM":
try:
som_l_f = obj.attr_list["Wavelength_final"]
except KeyError:
raise RuntimeError("Please provide a final wavelength "\
+"parameter either via the function call "\
+"or the SOM")
else:
if iobj is None:
raise RuntimeError("You need to provide a final wavelength")
else:
som_l_f = iobj.attr_list["Wavelength_final"]
if time_zero_slope is not None:
t_0_slope_descr = hlr_utils.get_descr(time_zero_slope)
else:
if o_descr == "SOM":
try:
t_0_slope = obj.attr_list["Time_zero_slope"][0]
t_0_slope_err2 = obj.attr_list["Time_zero_slope"][1]
except KeyError:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
else:
t_0_slope = TIME_ZERO_SLOPE[0]
t_0_slope_err2 = TIME_ZERO_SLOPE[1]
if time_zero_offset is not None:
t_0_offset_descr = hlr_utils.get_descr(time_zero_offset)
else:
if o_descr == "SOM":
try:
t_0_offset = obj.attr_list["Time_zero_offset"][0]
t_0_offset_err2 = obj.attr_list["Time_zero_offset"][1]
except KeyError:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
else:
t_0_offset = TIME_ZERO_OFFSET[0]
t_0_offset_err2 = TIME_ZERO_OFFSET[1]
if dist_source_sample is not None:
ls_descr = hlr_utils.get_descr(dist_source_sample)
# Do nothing, go on
else:
pass
if dist_sample_detector is not None:
ld_descr = hlr_utils.get_descr(dist_sample_detector)
# Do nothing, go on
else:
pass
# iterate through the values
import axis_manip
if lojac:
import utils
for i in xrange(hlr_utils.get_length(obj)):
val = hlr_utils.get_value(obj, i, o_descr, "x", axis)
err2 = hlr_utils.get_err2(obj, i, o_descr, "x", axis)
map_so = hlr_utils.get_map_so(mobj, None, i)
if dist_source_sample is None:
(L_s, L_s_err2) = hlr_utils.get_parameter("primary", map_so, inst)
else:
L_s = hlr_utils.get_value(dist_source_sample, i, ls_descr)
L_s_err2 = hlr_utils.get_err2(dist_source_sample, i, ls_descr)
if dist_sample_detector is None:
(L_d, L_d_err2) = hlr_utils.get_parameter("secondary", map_so,
inst)
else:
L_d = hlr_utils.get_value(dist_sample_detector, i, ld_descr)
L_d_err2 = hlr_utils.get_err2(dist_sample_detector, i, ld_descr)
if lambda_f is not None:
l_f = hlr_utils.get_value(lambda_f, i, l_descr)
l_f_err2 = hlr_utils.get_err2(lambda_f, i, l_descr)
else:
l_f_tuple = hlr_utils.get_special(som_l_f, map_so)
l_f = l_f_tuple[0]
l_f_err2 = l_f_tuple[1]
if time_zero_slope is not None:
t_0_slope = hlr_utils.get_value(time_zero_slope, i,
t_0_slope_descr)
t_0_slope_err2 = hlr_utils.get_err2(time_zero_slope, i,
t_0_slope_descr)
else:
pass
if time_zero_offset is not None:
t_0_offset = hlr_utils.get_value(time_zero_offset, i,
t_0_offset_descr)
t_0_offset_err2 = hlr_utils.get_err2(time_zero_offset, i,
t_0_offset_descr)
else:
pass
value = axis_manip.tof_to_initial_wavelength_igs_lin_time_zero(
val, err2,
l_f, l_f_err2,
t_0_slope, t_0_slope_err2,
t_0_offset, t_0_offset_err2,
L_s, L_s_err2,
L_d, L_d_err2)
# Remove all wavelengths < 0
if run_filter:
index = 0
for valx in value[0]:
if valx >= 0:
break
index += 1
value[0].__delslice__(0, index)
value[1].__delslice__(0, index)
map_so.y.__delslice__(0, index)
map_so.var_y.__delslice__(0, index)
if lojac:
val.__delslice__(0, index)
err2.__delslice__(0, index)
else:
pass
if lojac:
try:
counts = utils.linear_order_jacobian(val, value[0],
map_so.y, map_so.var_y)
except Exception, e:
# Lets us know offending pixel ID
raise Exception(str(map_so.id) + " " + str(e))
hlr_utils.result_insert(result, res_descr, counts, map_so,
"all", axis, [value[0]])
else:
hlr_utils.result_insert(result, res_descr, value, map_so,
"x", axis)
