def create_Qvec_vs_E_dgs(som, E_i, conf, **kwargs):
"""
This function starts with the energy transfer axis from DGS reduction and
turns this into a 4D spectra with Qx, Qy, Qz and Et axes.
@param som: The input object with initial IGS wavelength axis
@type som: C{SOM.SOM}
@param E_i: The initial energy for the given data.
@type E_i: C{tuple}
@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 timer: Timing object so the function can perform timing estimates.
@type timer: C{sns_timer.DiffTime}
@keyword corner_angles: The object that contains the corner geometry
information.
@type corner_angles: C{dict}
@keyword make_fixed: A flag that turns on writing the fixed grid mesh
information to a file.
@type make_fixed: C{boolean}
@keyword output: The output filename and or directory.
@type output: C{string}
"""
import array_manip
import axis_manip
import common_lib
import hlr_utils
import os
# Check keywords
try:
t = kwargs["timer"]
except KeyError:
t = None
corner_angles = kwargs["corner_angles"]
try:
make_fixed = kwargs["make_fixed"]
except KeyError:
make_fixed = False
try:
output = kwargs["output"]
except KeyError:
output = None
# Convert initial energy to initial wavevector
l_i = common_lib.energy_to_wavelength(E_i)
k_i = common_lib.wavelength_to_scalar_k(l_i)
# Since all the data is rebinned to the same energy transfer axis, we can
# calculate the final energy axis once
E_t = som[0].axis[0].val
if som[0].axis[0].var is not None:
E_t_err2 = som[0].axis[0].var
else:
import nessi_list
E_t_err2 = nessi_list.NessiList(len(E_t))
E_f = array_manip.sub_ncerr(E_i[0], E_i[1], E_t, E_t_err2)
# Check for negative final energies which will cause problems with
# wavelength conversion due to square root
if E_f[0][-1] < 0:
E_f[0].reverse()
E_f[1].reverse()
index = 0
for E in E_f[0]:
if E >= 0:
break
index += 1
E_f[0].__delslice__(0, index)
E_f[1].__delslice__(0, index)
E_f[0].reverse()
E_f[1].reverse()
len_E = len(E_f[0]) - 1
# Now we can get the final wavevector
l_f = axis_manip.energy_to_wavelength(E_f[0], E_f[1])
k_f = axis_manip.wavelength_to_scalar_k(l_f[0], l_f[1])
# Grab the instrument from the som
inst = som.attr_list.instrument
if make_fixed:
import SOM
fixed_grid = {}
for key in corner_angles:
so_id = SOM.NeXusId.fromString(key).toTuple()
try:
pathlength = inst.get_secondary(so_id)[0]
points = []
for j in range(4):
points.extend(
__calc_xyz(pathlength, corner_angles[key].getPolar(j),
corner_angles[key].getAzimuthal(j)))
fixed_grid[key] = points
except KeyError:
# Pixel ID is not in instrument geometry
pass
CNT = {}
ERR2 = {}
V1 = {}
V2 = {}
V3 = {}
V4 = {}
# Output positions for Qx, Qy, Qz coordinates
X = 0
Y = 2
Z = 4
if t is not None:
t.getTime(False)
# Iterate though the data
len_som = hlr_utils.get_length(som)
for i in xrange(len_som):
map_so = hlr_utils.get_map_so(som, None, i)
yval = hlr_utils.get_value(som, i, "SOM", "y")
yerr2 = hlr_utils.get_err2(som, i, "SOM", "y")
CNT[str(map_so.id)] = yval
ERR2[str(map_so.id)] = yerr2
cangles = corner_angles[str(map_so.id)]
Q1 = axis_manip.init_scatt_wavevector_to_Q(k_i[0], k_i[1], k_f[0],
k_f[1],
cangles.getAzimuthal(0),
0.0, cangles.getPolar(0),
0.0)
V1[str(map_so.id)] = {}
V1[str(map_so.id)]["x"] = Q1[X]
V1[str(map_so.id)]["y"] = Q1[Y]
V1[str(map_so.id)]["z"] = Q1[Z]
Q2 = axis_manip.init_scatt_wavevector_to_Q(k_i[0], k_i[1], k_f[0],
k_f[1],
cangles.getAzimuthal(1),
0.0, cangles.getPolar(1),
0.0)
V2[str(map_so.id)] = {}
V2[str(map_so.id)]["x"] = Q2[X]
V2[str(map_so.id)]["y"] = Q2[Y]
V2[str(map_so.id)]["z"] = Q2[Z]
Q3 = axis_manip.init_scatt_wavevector_to_Q(k_i[0], k_i[1], k_f[0],
k_f[1],
cangles.getAzimuthal(2),
0.0, cangles.getPolar(2),
0.0)
V3[str(map_so.id)] = {}
V3[str(map_so.id)]["x"] = Q3[X]
V3[str(map_so.id)]["y"] = Q3[Y]
V3[str(map_so.id)]["z"] = Q3[Z]
Q4 = axis_manip.init_scatt_wavevector_to_Q(k_i[0], k_i[1], k_f[0],
k_f[1],
cangles.getAzimuthal(3),
0.0, cangles.getPolar(3),
0.0)
V4[str(map_so.id)] = {}
V4[str(map_so.id)]["x"] = Q4[X]
V4[str(map_so.id)]["y"] = Q4[Y]
V4[str(map_so.id)]["z"] = Q4[Z]
if t is not None:
t.getTime(msg="After calculating verticies ")
# Form the messages
if t is not None:
t.getTime(False)
jobstr = 'MR' + hlr_utils.create_binner_string(conf) + 'JH'
num_lines = len(CNT) * len_E
linestr = str(num_lines)
if output is not None:
outdir = os.path.dirname(output)
if outdir != '':
if outdir.rfind('.') != -1:
outdir = ""
else:
outdir = ""
value = str(som.attr_list["data-run_number"].getValue()).split('/')
topdir = os.path.join(outdir, value[0].strip() + "-mesh")
try:
os.mkdir(topdir)
except OSError:
pass
outtag = os.path.basename(output)
if outtag.rfind('.') == -1:
outtag = ""
else:
outtag = outtag.split('.')[0]
if outtag != "":
filehead = outtag + "_bmesh"
if make_fixed:
filehead1 = outtag + "_fgrid"
filehead2 = outtag + "_conf"
else:
filehead = "bmesh"
if make_fixed:
filehead1 = "fgrid"
filehead2 = "conf"
hfile = open(os.path.join(topdir, "%s.in" % filehead2), "w")
print >> hfile, jobstr
print >> hfile, linestr
hfile.close()
import utils
use_zero_supp = not conf.no_zero_supp
for k in xrange(len_E):
ofile = open(os.path.join(topdir, "%s%04d.in" % (filehead, k)), "w")
if make_fixed:
ofile1 = open(os.path.join(topdir, "%s%04d.in" % (filehead1, k)),
"w")
for pid in CNT:
if use_zero_supp:
write_value = not utils.compare(CNT[pid][k], 0.0) == 0
else:
write_value = True
if write_value:
result = []
result.append(str(k))
result.append(str(E_t[k]))
result.append(str(E_t[k + 1]))
result.append(str(CNT[pid][k]))
result.append(str(ERR2[pid][k]))
__get_coords(V1, pid, k, result)
__get_coords(V2, pid, k, result)
__get_coords(V3, pid, k, result)
__get_coords(V4, pid, k, result)
__get_coords(V1, pid, k + 1, result)
__get_coords(V2, pid, k + 1, result)
__get_coords(V3, pid, k + 1, result)
__get_coords(V4, pid, k + 1, result)
print >> ofile, " ".join(result)
if make_fixed:
result1 = []
result1.append(str(k))
result1.append(str(E_t[k]))
result1.append(str(E_t[k + 1]))
result1.append(str(CNT[pid][k]))
result1.append(str(ERR2[pid][k]))
result1.extend([str(x) for x in fixed_grid[pid]])
print >> ofile1, " ".join(result1)
ofile.close()
if make_fixed:
ofile1.close()
if t is not None:
t.getTime(msg="After creating messages ")
def create_E_vs_Q_dgs(som, E_i, Q_final, **kwargs):
"""
This function starts with the rebinned energy transfer and turns this
into a 2D spectra with E and Q axes for DGS instruments.
@param som: The input object with initial IGS wavelength axis
@type som: C{SOM.SOM}
@param E_i: The initial energy for the given data.
@type E_i: C{tuple}
@param Q_final: The momentum transfer axis to rebin the data to
@type Q_final: C{nessi_list.NessiList}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword corner_angles: The object that contains the corner geometry
information.
@type corner_angles: C{dict}
@keyword so_id: The identifier represents a number, string, tuple or other
object that describes the resulting C{SO}
@type so_id: C{int}, C{string}, C{tuple}, C{pixel ID}
@keyword y_label: The y axis label
@type y_label: C{string}
@keyword y_units: The y axis units
@type y_units: C{string}
@keyword x_labels: This is a list of names that sets the individual x axis
labels
@type x_labels: C{list} of C{string}s
@keyword x_units: This is a list of names that sets the individual x axis
units
@type x_units: C{list} of C{string}s
@keyword split: This flag causes the counts and the fractional area to
be written out into separate files.
@type split: C{boolean}
@keyword configure: This is the object containing the driver configuration.
@type configure: C{Configure}
@return: Object containing a 2D C{SO} with E and Q axes
@rtype: C{SOM.SOM}
"""
import array_manip
import axis_manip
import common_lib
import hlr_utils
import nessi_list
import SOM
import utils
# Check for keywords
corner_angles = kwargs["corner_angles"]
configure = kwargs.get("configure")
split = kwargs.get("split", False)
# Setup output object
so_dim = SOM.SO(2)
so_dim.axis[0].val = Q_final
so_dim.axis[1].val = som[0].axis[0].val # E_t
# Calculate total 2D array size
N_tot = (len(so_dim.axis[0].val) - 1) * (len(so_dim.axis[1].val) - 1)
# Create y and var_y lists from total 2D size
so_dim.y = nessi_list.NessiList(N_tot)
so_dim.var_y = nessi_list.NessiList(N_tot)
# Create area sum and errors for the area sum lists from total 2D size
area_sum = nessi_list.NessiList(N_tot)
area_sum_err2 = nessi_list.NessiList(N_tot)
# Convert initial energy to initial wavevector
l_i = common_lib.energy_to_wavelength(E_i)
k_i = common_lib.wavelength_to_scalar_k(l_i)
# Since all the data is rebinned to the same energy transfer axis, we can
# calculate the final energy axis once
E_t = som[0].axis[0].val
if som[0].axis[0].var is not None:
E_t_err2 = som[0].axis[0].var
else:
E_t_err2 = nessi_list.NessiList(len(E_t))
# Get the bin width arrays from E_t
(E_t_bw, E_t_bw_err2) = utils.calc_bin_widths(E_t)
E_f = array_manip.sub_ncerr(E_i[0], E_i[1], E_t, E_t_err2)
# Now we can get the final wavevector
l_f = axis_manip.energy_to_wavelength(E_f[0], E_f[1])
k_f = axis_manip.wavelength_to_scalar_k(l_f[0], l_f[1])
# Output position for Q
X = 0
# Iterate though the data
len_som = hlr_utils.get_length(som)
for i in xrange(len_som):
map_so = hlr_utils.get_map_so(som, None, i)
yval = hlr_utils.get_value(som, i, "SOM", "y")
yerr2 = hlr_utils.get_err2(som, i, "SOM", "y")
cangles = corner_angles[str(map_so.id)]
avg_theta1 = (cangles.getPolar(0) + cangles.getPolar(1)) / 2.0
avg_theta2 = (cangles.getPolar(2) + cangles.getPolar(3)) / 2.0
Q1 = axis_manip.init_scatt_wavevector_to_scalar_Q(
k_i[0], k_i[1], k_f[0][:-1], k_f[1][:-1], avg_theta2, 0.0)
Q2 = axis_manip.init_scatt_wavevector_to_scalar_Q(
k_i[0], k_i[1], k_f[0][:-1], k_f[1][:-1], avg_theta1, 0.0)
Q3 = axis_manip.init_scatt_wavevector_to_scalar_Q(
k_i[0], k_i[1], k_f[0][1:], k_f[1][1:], avg_theta1, 0.0)
Q4 = axis_manip.init_scatt_wavevector_to_scalar_Q(
k_i[0], k_i[1], k_f[0][1:], k_f[1][1:], avg_theta2, 0.0)
# Calculate the area of the E,Q polygons
(A, A_err2) = utils.calc_eq_jacobian_dgs(E_t[:-1], E_t[:-1], E_t[1:],
E_t[1:], Q1[X], Q2[X], Q3[X],
Q4[X])
# Apply the Jacobian: C/dE_t * dE_t / A(EQ) = C/A(EQ)
(jac_ratio,
jac_ratio_err2) = array_manip.div_ncerr(E_t_bw, E_t_bw_err2, A,
A_err2)
(counts, counts_err2) = array_manip.mult_ncerr(yval, yerr2, jac_ratio,
jac_ratio_err2)
try:
(y_2d, y_2d_err2, area_new,
bin_count) = axis_manip.rebin_2D_quad_to_rectlin(
Q1[X], E_t[:-1], Q2[X], E_t[:-1], Q3[X], E_t[1:], Q4[X],
E_t[1:], counts, counts_err2, so_dim.axis[0].val,
so_dim.axis[1].val)
del bin_count
except IndexError, e:
# Get the offending index from the error message
index = int(str(e).split()[1].split('index')[-1].strip('[]'))
print "Id:", map_so.id
print "Index:", index
print "Verticies: %f, %f, %f, %f, %f, %f, %f, %f" % (
Q1[X][index], E_t[:-1][index], Q2[X][index], E_t[:-1][index],
Q3[X][index], E_t[1:][index], Q4[X][index], E_t[1:][index])
raise IndexError(str(e))
# Add in together with previous results
(so_dim.y,
so_dim.var_y) = array_manip.add_ncerr(so_dim.y, so_dim.var_y, y_2d,
y_2d_err2)
(area_sum,
area_sum_err2) = array_manip.add_ncerr(area_sum, area_sum_err2,
area_new, area_sum_err2)
def create_E_vs_Q_dgs(som, E_i, Q_final, **kwargs):
"""
This function starts with the rebinned energy transfer and turns this
into a 2D spectra with E and Q axes for DGS instruments.
@param som: The input object with initial IGS wavelength axis
@type som: C{SOM.SOM}
@param E_i: The initial energy for the given data.
@type E_i: C{tuple}
@param Q_final: The momentum transfer axis to rebin the data to
@type Q_final: C{nessi_list.NessiList}
@param kwargs: A list of keyword arguments that the function accepts:
@keyword corner_angles: The object that contains the corner geometry
information.
@type corner_angles: C{dict}
@keyword so_id: The identifier represents a number, string, tuple or other
object that describes the resulting C{SO}
@type so_id: C{int}, C{string}, C{tuple}, C{pixel ID}
@keyword y_label: The y axis label
@type y_label: C{string}
@keyword y_units: The y axis units
@type y_units: C{string}
@keyword x_labels: This is a list of names that sets the individual x axis
labels
@type x_labels: C{list} of C{string}s
@keyword x_units: This is a list of names that sets the individual x axis
units
@type x_units: C{list} of C{string}s
@keyword split: This flag causes the counts and the fractional area to
be written out into separate files.
@type split: C{boolean}
@keyword configure: This is the object containing the driver configuration.
@type configure: C{Configure}
@return: Object containing a 2D C{SO} with E and Q axes
@rtype: C{SOM.SOM}
"""
import array_manip
import axis_manip
import common_lib
import hlr_utils
import nessi_list
import SOM
import utils
# Check for keywords
corner_angles = kwargs["corner_angles"]
configure = kwargs.get("configure")
split = kwargs.get("split", False)
# Setup output object
so_dim = SOM.SO(2)
so_dim.axis[0].val = Q_final
so_dim.axis[1].val = som[0].axis[0].val # E_t
# Calculate total 2D array size
N_tot = (len(so_dim.axis[0].val) - 1) * (len(so_dim.axis[1].val) - 1)
# Create y and var_y lists from total 2D size
so_dim.y = nessi_list.NessiList(N_tot)
so_dim.var_y = nessi_list.NessiList(N_tot)
# Create area sum and errors for the area sum lists from total 2D size
area_sum = nessi_list.NessiList(N_tot)
area_sum_err2 = nessi_list.NessiList(N_tot)
# Convert initial energy to initial wavevector
l_i = common_lib.energy_to_wavelength(E_i)
k_i = common_lib.wavelength_to_scalar_k(l_i)
# Since all the data is rebinned to the same energy transfer axis, we can
# calculate the final energy axis once
E_t = som[0].axis[0].val
if som[0].axis[0].var is not None:
E_t_err2 = som[0].axis[0].var
else:
E_t_err2 = nessi_list.NessiList(len(E_t))
# Get the bin width arrays from E_t
(E_t_bw, E_t_bw_err2) = utils.calc_bin_widths(E_t)
E_f = array_manip.sub_ncerr(E_i[0], E_i[1], E_t, E_t_err2)
# Now we can get the final wavevector
l_f = axis_manip.energy_to_wavelength(E_f[0], E_f[1])
k_f = axis_manip.wavelength_to_scalar_k(l_f[0], l_f[1])
# Output position for Q
X = 0
# Iterate though the data
len_som = hlr_utils.get_length(som)
for i in xrange(len_som):
map_so = hlr_utils.get_map_so(som, None, i)
yval = hlr_utils.get_value(som, i, "SOM", "y")
yerr2 = hlr_utils.get_err2(som, i, "SOM", "y")
cangles = corner_angles[str(map_so.id)]
avg_theta1 = (cangles.getPolar(0) + cangles.getPolar(1)) / 2.0
avg_theta2 = (cangles.getPolar(2) + cangles.getPolar(3)) / 2.0
Q1 = axis_manip.init_scatt_wavevector_to_scalar_Q(k_i[0],
k_i[1],
k_f[0][:-1],
k_f[1][:-1],
avg_theta2,
0.0)
Q2 = axis_manip.init_scatt_wavevector_to_scalar_Q(k_i[0],
k_i[1],
k_f[0][:-1],
k_f[1][:-1],
avg_theta1,
0.0)
Q3 = axis_manip.init_scatt_wavevector_to_scalar_Q(k_i[0],
k_i[1],
k_f[0][1:],
k_f[1][1:],
avg_theta1,
0.0)
Q4 = axis_manip.init_scatt_wavevector_to_scalar_Q(k_i[0],
k_i[1],
k_f[0][1:],
k_f[1][1:],
avg_theta2,
0.0)
# Calculate the area of the E,Q polygons
(A, A_err2) = utils.calc_eq_jacobian_dgs(E_t[:-1], E_t[:-1],
E_t[1:], E_t[1:],
Q1[X], Q2[X], Q3[X], Q4[X])
# Apply the Jacobian: C/dE_t * dE_t / A(EQ) = C/A(EQ)
(jac_ratio, jac_ratio_err2) = array_manip.div_ncerr(E_t_bw,
E_t_bw_err2,
A, A_err2)
(counts, counts_err2) = array_manip.mult_ncerr(yval, yerr2,
jac_ratio,
jac_ratio_err2)
try:
(y_2d, y_2d_err2,
area_new,
bin_count) = axis_manip.rebin_2D_quad_to_rectlin(Q1[X], E_t[:-1],
Q2[X], E_t[:-1],
Q3[X], E_t[1:],
Q4[X], E_t[1:],
counts,
counts_err2,
so_dim.axis[0].val,
so_dim.axis[1].val)
del bin_count
except IndexError, e:
# Get the offending index from the error message
index = int(str(e).split()[1].split('index')[-1].strip('[]'))
print "Id:", map_so.id
print "Index:", index
print "Verticies: %f, %f, %f, %f, %f, %f, %f, %f" % (Q1[X][index],
E_t[:-1][index],
Q2[X][index],
E_t[:-1][index],
Q3[X][index],
E_t[1:][index],
Q4[X][index],
E_t[1:][index])
raise IndexError(str(e))
# Add in together with previous results
(so_dim.y, so_dim.var_y) = array_manip.add_ncerr(so_dim.y,
so_dim.var_y,
y_2d, y_2d_err2)
(area_sum, area_sum_err2) = array_manip.add_ncerr(area_sum,
area_sum_err2,
area_new,
area_sum_err2)
def create_Qvec_vs_E_dgs(som, E_i, conf, **kwargs):
"""
This function starts with the energy transfer axis from DGS reduction and
turns this into a 4D spectra with Qx, Qy, Qz and Et axes.
@param som: The input object with initial IGS wavelength axis
@type som: C{SOM.SOM}
@param E_i: The initial energy for the given data.
@type E_i: C{tuple}
@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 timer: Timing object so the function can perform timing estimates.
@type timer: C{sns_timer.DiffTime}
@keyword corner_angles: The object that contains the corner geometry
information.
@type corner_angles: C{dict}
@keyword make_fixed: A flag that turns on writing the fixed grid mesh
information to a file.
@type make_fixed: C{boolean}
@keyword output: The output filename and or directory.
@type output: C{string}
"""
import array_manip
import axis_manip
import common_lib
import hlr_utils
import os
# Check keywords
try:
t = kwargs["timer"]
except KeyError:
t = None
corner_angles = kwargs["corner_angles"]
try:
make_fixed = kwargs["make_fixed"]
except KeyError:
make_fixed = False
try:
output = kwargs["output"]
except KeyError:
output = None
# Convert initial energy to initial wavevector
l_i = common_lib.energy_to_wavelength(E_i)
k_i = common_lib.wavelength_to_scalar_k(l_i)
# Since all the data is rebinned to the same energy transfer axis, we can
# calculate the final energy axis once
E_t = som[0].axis[0].val
if som[0].axis[0].var is not None:
E_t_err2 = som[0].axis[0].var
else:
import nessi_list
E_t_err2 = nessi_list.NessiList(len(E_t))
E_f = array_manip.sub_ncerr(E_i[0], E_i[1], E_t, E_t_err2)
# Check for negative final energies which will cause problems with
# wavelength conversion due to square root
if E_f[0][-1] < 0:
E_f[0].reverse()
E_f[1].reverse()
index = 0
for E in E_f[0]:
if E >= 0:
break
index += 1
E_f[0].__delslice__(0, index)
E_f[1].__delslice__(0, index)
E_f[0].reverse()
E_f[1].reverse()
len_E = len(E_f[0]) - 1
# Now we can get the final wavevector
l_f = axis_manip.energy_to_wavelength(E_f[0], E_f[1])
k_f = axis_manip.wavelength_to_scalar_k(l_f[0], l_f[1])
# Grab the instrument from the som
inst = som.attr_list.instrument
if make_fixed:
import SOM
fixed_grid = {}
for key in corner_angles:
so_id = SOM.NeXusId.fromString(key).toTuple()
try:
pathlength = inst.get_secondary(so_id)[0]
points = []
for j in range(4):
points.extend(__calc_xyz(pathlength,
corner_angles[key].getPolar(j),
corner_angles[key].getAzimuthal(j)))
fixed_grid[key] = points
except KeyError:
# Pixel ID is not in instrument geometry
pass
CNT = {}
ERR2 = {}
V1 = {}
V2 = {}
V3 = {}
V4 = {}
# Output positions for Qx, Qy, Qz coordinates
X = 0
Y = 2
Z = 4
if t is not None:
t.getTime(False)
# Iterate though the data
len_som = hlr_utils.get_length(som)
for i in xrange(len_som):
map_so = hlr_utils.get_map_so(som, None, i)
yval = hlr_utils.get_value(som, i, "SOM", "y")
yerr2 = hlr_utils.get_err2(som, i, "SOM", "y")
CNT[str(map_so.id)] = yval
ERR2[str(map_so.id)] = yerr2
cangles = corner_angles[str(map_so.id)]
Q1 = axis_manip.init_scatt_wavevector_to_Q(k_i[0], k_i[1],
k_f[0], k_f[1],
cangles.getAzimuthal(0),
0.0,
cangles.getPolar(0),
0.0)
V1[str(map_so.id)] = {}
V1[str(map_so.id)]["x"] = Q1[X]
V1[str(map_so.id)]["y"] = Q1[Y]
V1[str(map_so.id)]["z"] = Q1[Z]
Q2 = axis_manip.init_scatt_wavevector_to_Q(k_i[0], k_i[1],
k_f[0], k_f[1],
cangles.getAzimuthal(1),
0.0,
cangles.getPolar(1),
0.0)
V2[str(map_so.id)] = {}
V2[str(map_so.id)]["x"] = Q2[X]
V2[str(map_so.id)]["y"] = Q2[Y]
V2[str(map_so.id)]["z"] = Q2[Z]
Q3 = axis_manip.init_scatt_wavevector_to_Q(k_i[0], k_i[1],
k_f[0], k_f[1],
cangles.getAzimuthal(2),
0.0,
cangles.getPolar(2),
0.0)
V3[str(map_so.id)] = {}
V3[str(map_so.id)]["x"] = Q3[X]
V3[str(map_so.id)]["y"] = Q3[Y]
V3[str(map_so.id)]["z"] = Q3[Z]
Q4 = axis_manip.init_scatt_wavevector_to_Q(k_i[0], k_i[1],
k_f[0], k_f[1],
cangles.getAzimuthal(3),
0.0,
cangles.getPolar(3),
0.0)
V4[str(map_so.id)] = {}
V4[str(map_so.id)]["x"] = Q4[X]
V4[str(map_so.id)]["y"] = Q4[Y]
V4[str(map_so.id)]["z"] = Q4[Z]
if t is not None:
t.getTime(msg="After calculating verticies ")
# Form the messages
if t is not None:
t.getTime(False)
jobstr = 'MR' + hlr_utils.create_binner_string(conf) + 'JH'
num_lines = len(CNT) * len_E
linestr = str(num_lines)
if output is not None:
outdir = os.path.dirname(output)
if outdir != '':
if outdir.rfind('.') != -1:
outdir = ""
else:
outdir = ""
value = str(som.attr_list["data-run_number"].getValue()).split('/')
topdir = os.path.join(outdir, value[0].strip() + "-mesh")
try:
os.mkdir(topdir)
except OSError:
pass
outtag = os.path.basename(output)
if outtag.rfind('.') == -1:
outtag = ""
else:
outtag = outtag.split('.')[0]
if outtag != "":
filehead = outtag + "_bmesh"
if make_fixed:
filehead1 = outtag + "_fgrid"
filehead2 = outtag + "_conf"
else:
filehead = "bmesh"
if make_fixed:
filehead1 = "fgrid"
filehead2 = "conf"
hfile = open(os.path.join(topdir, "%s.in" % filehead2), "w")
print >> hfile, jobstr
print >> hfile, linestr
hfile.close()
import utils
use_zero_supp = not conf.no_zero_supp
for k in xrange(len_E):
ofile = open(os.path.join(topdir, "%s%04d.in" % (filehead, k)), "w")
if make_fixed:
ofile1 = open(os.path.join(topdir, "%s%04d.in" % (filehead1, k)),
"w")
for pid in CNT:
if use_zero_supp:
write_value = not utils.compare(CNT[pid][k], 0.0) == 0
else:
write_value = True
if write_value:
result = []
result.append(str(k))
result.append(str(E_t[k]))
result.append(str(E_t[k+1]))
result.append(str(CNT[pid][k]))
result.append(str(ERR2[pid][k]))
__get_coords(V1, pid, k, result)
__get_coords(V2, pid, k, result)
__get_coords(V3, pid, k, result)
__get_coords(V4, pid, k, result)
__get_coords(V1, pid, k+1, result)
__get_coords(V2, pid, k+1, result)
__get_coords(V3, pid, k+1, result)
__get_coords(V4, pid, k+1, result)
print >> ofile, " ".join(result)
if make_fixed:
result1 = []
result1.append(str(k))
result1.append(str(E_t[k]))
result1.append(str(E_t[k+1]))
result1.append(str(CNT[pid][k]))
result1.append(str(ERR2[pid][k]))
result1.extend([str(x) for x in fixed_grid[pid]])
print >> ofile1, " ".join(result1)
ofile.close()
if make_fixed:
ofile1.close()
if t is not None:
t.getTime(msg="After creating messages ")
