def add_intermediate(self):
"""
This method stores any intermediate objects within the final data set after fully reading the set.
:param parent: The NXclass name for the h5py Group object that just finished being processed
"""
if self.parent_class == u'SASprocess':
self.current_datainfo.process.append(self.process)
self.process = Process()
elif self.parent_class == u'SASdetector':
self.current_datainfo.detector.append(self.detector)
self.detector = Detector()
elif self.parent_class == u'SAStransmission_spectrum':
self.current_datainfo.trans_spectrum.append(self.trans_spectrum)
self.trans_spectrum = TransmissionSpectrum()
elif self.parent_class == u'SAScollimation':
self.current_datainfo.collimation.append(self.collimation)
self.collimation = Collimation()
elif self.parent_class == u'SASaperture':
self.collimation.aperture.append(self.aperture)
self.aperture = Aperture()
elif self.parent_class == u'SASdata':
if type(self.current_dataset) is plottable_2D:
self.data2d.append(self.current_dataset)
elif type(self.current_dataset) is plottable_1D:
self.data1d.append(self.current_dataset)
def convert_image(self, rgb, xmin, xmax, ymin, ymax, zscale):
"""
Convert image to data2D
"""
x_len = len(rgb[0])
y_len = len(rgb)
x_vals = np.linspace(xmin, xmax, num=x_len)
y_vals = np.linspace(ymin, ymax, num=y_len)
# Instantiate data object
output = Data2D()
output.filename = os.path.basename(self.title)
output.id = output.filename
detector = Detector()
detector.pixel_size.x = None
detector.pixel_size.y = None
# Store the sample to detector distance
detector.distance = None
output.detector.append(detector)
# Initiazed the output data object
output.data = zscale * self.rgb2gray(rgb)
output.err_data = np.zeros([x_len, y_len])
output.mask = np.ones([x_len, y_len], dtype=bool)
output.xbins = x_len
output.ybins = y_len
output.x_bins = x_vals
output.y_bins = y_vals
output.qx_data = np.array(x_vals)
output.qy_data = np.array(y_vals)
output.xmin = xmin
output.xmax = xmax
output.ymin = ymin
output.ymax = ymax
output.xaxis('\\rm{Q_{x}}', '\AA^{-1}')
output.yaxis('\\rm{Q_{y}}', '\AA^{-1}')
# Store loading process information
output.meta_data['loader'] = self.title.split('.')[-1] + "Reader"
output.is_data = True
output = reader2D_converter(output)
if self.base is not None:
data = self.base.create_gui_data(output, self.title)
self.base.add_data({data.id:data})
def convert_image(self, rgb, xmin, xmax, ymin, ymax, zscale):
"""
Convert image to data2D
"""
x_len = len(rgb[0])
y_len = len(rgb)
x_vals = np.linspace(xmin, xmax, num=x_len)
y_vals = np.linspace(ymin, ymax, num=y_len)
# Instantiate data object
output = Data2D()
output.filename = os.path.basename(self.title)
output.id = output.filename
detector = Detector()
detector.pixel_size.x = None
detector.pixel_size.y = None
# Store the sample to detector distance
detector.distance = None
output.detector.append(detector)
# Initiazed the output data object
output.data = zscale * self.rgb2gray(rgb)
output.err_data = np.zeros([x_len, y_len])
output.mask = np.ones([x_len, y_len], dtype=bool)
output.xbins = x_len
output.ybins = y_len
output.x_bins = x_vals
output.y_bins = y_vals
output.qx_data = np.array(x_vals)
output.qy_data = np.array(y_vals)
output.xmin = xmin
output.xmax = xmax
output.ymin = ymin
output.ymax = ymax
output.xaxis('\\rm{Q_{x}}', '\AA^{-1}')
output.yaxis('\\rm{Q_{y}}', '\AA^{-1}')
# Store loading process information
output.meta_data['loader'] = self.title.split('.')[-1] + "Reader"
output.is_data = True
output = reader2D_converter(output)
if self.base is not None:
data = self.base.create_gui_data(output, self.title)
self.base.add_data({data.id: data})
def add_detector(self, event):
"""
Append empty detector to data's list of detector
"""
if not self.detector_cbox.IsEnabled():
self.detector_cbox.Enable()
detector = Detector()
self._detector.append(detector)
position = self.detector_cbox.Append(str(detector.name))
self.detector_cbox.SetClientData(position, detector)
self.detector_cbox.SetSelection(position)
self.enable_detector()
self.set_values()
def _parse_child(self, dom, parent=''):
"""
Recursive method for stepping through the embedded XML
:param dom: XML node with or without children
"""
for node in dom:
tagname = node.tag
value = node.text
attr = node.attrib
key = attr.get("key", '')
if len(node.getchildren()) > 1:
self._parse_child(node, key)
if key == "SampleDetector":
self.current_datainfo.detector.append(self.detector)
self.detector = Detector()
else:
if key == "value":
if parent == "Wavelength":
self.current_datainfo.source.wavelength = value
elif parent == "SampleDetector":
self.detector.distance = value
elif parent == "Temperature":
self.current_datainfo.sample.temperature = value
elif parent == "CounterSlitLength":
self.detector.slit_length = value
elif key == "unit":
value = value.replace("_", "")
if parent == "Wavelength":
self.current_datainfo.source.wavelength_unit = value
elif parent == "SampleDetector":
self.detector.distance_unit = value
elif parent == "X":
self.current_dataset.xaxis(self.current_dataset._xaxis,
value)
elif parent == "Y":
self.current_dataset.yaxis(self.current_dataset._yaxis,
value)
elif parent == "Temperature":
self.current_datainfo.sample.temperature_unit = value
elif parent == "CounterSlitLength":
self.detector.slit_length_unit = value
elif key == "quantity":
if parent == "X":
self.current_dataset.xaxis(value,
self.current_dataset._xunit)
elif parent == "Y":
self.current_dataset.yaxis(value,
self.current_dataset._yunit)
def reset_state(self):
self.current_dataset = plottable_1D(np.empty(0), np.empty(0), np.empty(0), np.empty(0))
self.current_datainfo = DataInfo()
self.datasets = []
self.raw_data = None
self.errors = set()
self.logging = []
self.output = []
self.detector = Detector()
self.collimation = Collimation()
self.aperture = Aperture()
self.process = Process()
self.source = Source()
self.sample = Sample()
self.trans_spectrum = TransmissionSpectrum()
self.upper = 5
self.lower = 5
def reset_class_variables(self):
"""
Create the reader object and define initial states for class variables
"""
self.current_datainfo = None
self.current_dataset = None
self.data1d = []
self.data2d = []
self.raw_data = None
self.errors = set()
self.logging = []
self.output = []
self.parent_class = u''
self.detector = Detector()
self.collimation = Collimation()
self.aperture = Aperture()
self.process = Process()
self.trans_spectrum = TransmissionSpectrum()
def __init__(self, parent, base=None, *args, **kwargs):
ScrolledPanel.__init__(self, parent, *args, **kwargs)
PanelBase.__init__(self)
self.SetupScrolling()
self.SetWindowVariant(variant=FONT_VARIANT)
self.base = base
self.parent = parent
self.meta_frames = []
# GUI inputs
self.q_input = None
self.iq_input = None
self.output = None
self.radiation_input = None
self.convert_btn = None
self.metadata_section = None
self.data_type = "ascii"
# Metadata values
self.title = ''
self.run = ''
self.run_name = ''
self.instrument = ''
self.detector = Detector()
self.sample = Sample()
self.source = Source()
self.properties = ['title', 'run', 'run_name', 'instrument']
self.detector.name = ''
self.source.radiation = 'neutron'
self._do_layout()
self.SetAutoLayout(True)
self.Layout()
def read(self, filename=None):
"""
Open and read the data in a file
@param file: path of the file
"""
read_it = False
for item in self.ext:
if filename.lower().find(item) >= 0:
read_it = True
if read_it:
try:
datafile = open(filename, 'r')
except:
raise RuntimeError,"danse_reader cannot open %s" % (filename)
# defaults
# wavelength in Angstrom
wavelength = 10.0
# Distance in meter
distance = 11.0
# Pixel number of center in x
center_x = 65
# Pixel number of center in y
center_y = 65
# Pixel size [mm]
pixel = 5.0
# Size in x, in pixels
size_x = 128
# Size in y, in pixels
size_y = 128
# Format version
fversion = 1.0
output = Data2D()
output.filename = os.path.basename(filename)
detector = Detector()
output.detector.append(detector)
output.data = numpy.zeros([size_x,size_y])
output.err_data = numpy.zeros([size_x, size_y])
data_conv_q = None
data_conv_i = None
if has_converter == True and output.Q_unit != '1/A':
data_conv_q = Converter('1/A')
# Test it
data_conv_q(1.0, output.Q_unit)
if has_converter == True and output.I_unit != '1/cm':
data_conv_i = Converter('1/cm')
# Test it
data_conv_i(1.0, output.I_unit)
read_on = True
while read_on:
line = datafile.readline()
if line.find("DATA:") >= 0:
read_on = False
break
toks = line.split(':')
if toks[0] == "FORMATVERSION":
fversion = float(toks[1])
if toks[0] == "WAVELENGTH":
wavelength = float(toks[1])
elif toks[0] == "DISTANCE":
distance = float(toks[1])
elif toks[0] == "CENTER_X":
center_x = float(toks[1])
elif toks[0] == "CENTER_Y":
center_y = float(toks[1])
elif toks[0] == "PIXELSIZE":
pixel = float(toks[1])
elif toks[0] == "SIZE_X":
size_x = int(toks[1])
elif toks[0] == "SIZE_Y":
size_y = int(toks[1])
# Read the data
data = []
error = []
if fversion == 1.0:
data_str = datafile.readline()
data = data_str.split(' ')
else:
read_on = True
while read_on:
data_str = datafile.readline()
if len(data_str) == 0:
read_on = False
else:
toks = data_str.split()
try:
val = float(toks[0])
err = float(toks[1])
if data_conv_i is not None:
val = data_conv_i(val, units=output._yunit)
err = data_conv_i(err, units=output._yunit)
data.append(val)
error.append(err)
except:
logging.info("Skipping line:%s,%s" %(data_str,
sys.exc_value))
# Initialize
x_vals = []
y_vals = []
ymin = None
ymax = None
xmin = None
xmax = None
# Qx and Qy vectors
theta = pixel / distance / 100.0
stepq = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
for i_x in range(size_x):
theta = (i_x - center_x + 1) * pixel / distance / 100.0
qx = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
if has_converter == True and output.Q_unit != '1/A':
qx = data_conv_q(qx, units=output.Q_unit)
x_vals.append(qx)
if xmin == None or qx < xmin:
xmin = qx
if xmax == None or qx > xmax:
xmax = qx
ymin = None
ymax = None
for i_y in range(size_y):
theta = (i_y - center_y + 1) * pixel / distance / 100.0
qy = 4.0 * math.pi / wavelength * math.sin(theta/2.0)
if has_converter == True and output.Q_unit != '1/A':
qy = data_conv_q(qy, units=output.Q_unit)
y_vals.append(qy)
if ymin == None or qy < ymin:
ymin = qy
if ymax == None or qy > ymax:
ymax = qy
# Store the data in the 2D array
i_x = 0
i_y = -1
for i_pt in range(len(data)):
try:
value = float(data[i_pt])
except:
# For version 1.0, the data were still
# stored as strings at this point.
msg = "Skipping entry (v1.0):%s,%s" % (str(data[i_pt]),
sys.exc_value)
logging.info(msg)
# Get bin number
if math.fmod(i_pt, size_x) == 0:
i_x = 0
i_y += 1
else:
i_x += 1
output.data[i_y][i_x] = value
if fversion>1.0:
output.err_data[i_y][i_x] = error[i_pt]
# Store all data
# Store wavelength
if has_converter == True and output.source.wavelength_unit != 'A':
conv = Converter('A')
wavelength = conv(wavelength,
units=output.source.wavelength_unit)
output.source.wavelength = wavelength
# Store distance
if has_converter == True and detector.distance_unit != 'm':
conv = Converter('m')
distance = conv(distance, units=detector.distance_unit)
detector.distance = distance
# Store pixel size
if has_converter == True and detector.pixel_size_unit != 'mm':
conv = Converter('mm')
pixel = conv(pixel, units=detector.pixel_size_unit)
detector.pixel_size.x = pixel
detector.pixel_size.y = pixel
# Store beam center in distance units
detector.beam_center.x = center_x * pixel
detector.beam_center.y = center_y * pixel
# Store limits of the image (2D array)
xmin = xmin - stepq / 2.0
xmax = xmax + stepq / 2.0
ymin = ymin - stepq /2.0
ymax = ymax + stepq / 2.0
if has_converter == True and output.Q_unit != '1/A':
xmin = data_conv_q(xmin, units=output.Q_unit)
xmax = data_conv_q(xmax, units=output.Q_unit)
ymin = data_conv_q(ymin, units=output.Q_unit)
ymax = data_conv_q(ymax, units=output.Q_unit)
output.xmin = xmin
output.xmax = xmax
output.ymin = ymin
output.ymax = ymax
# Store x and y axis bin centers
output.x_bins = x_vals
output.y_bins = y_vals
# Units
if data_conv_q is not None:
output.xaxis("\\rm{Q_{x}}", output.Q_unit)
output.yaxis("\\rm{Q_{y}}", output.Q_unit)
else:
output.xaxis("\\rm{Q_{x}}", 'A^{-1}')
output.yaxis("\\rm{Q_{y}}", 'A^{-1}')
if data_conv_i is not None:
output.zaxis("\\rm{Intensity}", output.I_unit)
else:
output.zaxis("\\rm{Intensity}", "cm^{-1}")
if not fversion >= 1.0:
msg = "Danse_reader can't read this file %s" % filename
raise ValueError, msg
else:
logging.info("Danse_reader Reading %s \n" % filename)
# Store loading process information
output.meta_data['loader'] = self.type_name
output = reader2D_converter(output)
return output
return None
def read(self, path):
"""
Load data file.
:param path: file path
:return: Data1D object, or None
:raise RuntimeError: when the file can't be opened
:raise ValueError: when the length of the data vectors are inconsistent
"""
if os.path.isfile(path):
basename = os.path.basename(path)
root, extension = os.path.splitext(basename)
if extension.lower() in self.ext:
try:
input_f = open(path, 'r')
except:
raise RuntimeError, "abs_reader: cannot open %s" % path
buff = input_f.read()
lines = buff.split('\n')
x = np.zeros(0)
y = np.zeros(0)
dy = np.zeros(0)
dx = np.zeros(0)
output = Data1D(x, y, dy=dy, dx=dx)
detector = Detector()
output.detector.append(detector)
output.filename = basename
is_info = False
is_center = False
is_data_started = False
data_conv_q = None
data_conv_i = None
if has_converter == True and output.x_unit != '1/A':
data_conv_q = Converter('1/A')
# Test it
data_conv_q(1.0, output.x_unit)
if has_converter == True and output.y_unit != '1/cm':
data_conv_i = Converter('1/cm')
# Test it
data_conv_i(1.0, output.y_unit)
for line in lines:
# Information line 1
if is_info == True:
is_info = False
line_toks = line.split()
# Wavelength in Angstrom
try:
value = float(line_toks[1])
if has_converter == True and \
output.source.wavelength_unit != 'A':
conv = Converter('A')
output.source.wavelength = conv(
value, units=output.source.wavelength_unit)
else:
output.source.wavelength = value
except:
#goes to ASC reader
msg = "abs_reader: cannot open %s" % path
raise RuntimeError, msg
# Distance in meters
try:
value = float(line_toks[3])
if has_converter == True and \
detector.distance_unit != 'm':
conv = Converter('m')
detector.distance = conv(
value, units=detector.distance_unit)
else:
detector.distance = value
except:
#goes to ASC reader
msg = "abs_reader: cannot open %s" % path
raise RuntimeError, msg
# Transmission
try:
output.sample.transmission = float(line_toks[4])
except:
# Transmission is not a mandatory entry
pass
# Thickness in mm
try:
value = float(line_toks[5])
if has_converter == True and \
output.sample.thickness_unit != 'cm':
conv = Converter('cm')
output.sample.thickness = conv(
value, units=output.sample.thickness_unit)
else:
output.sample.thickness = value
except:
# Thickness is not a mandatory entry
pass
#MON CNT LAMBDA DET ANG DET DIST TRANS THICK
# AVE STEP
if line.count("LAMBDA") > 0:
is_info = True
# Find center info line
if is_center == True:
is_center = False
line_toks = line.split()
# Center in bin number
center_x = float(line_toks[0])
center_y = float(line_toks[1])
# Bin size
if has_converter == True and \
detector.pixel_size_unit != 'mm':
conv = Converter('mm')
detector.pixel_size.x = conv(
5.0, units=detector.pixel_size_unit)
detector.pixel_size.y = conv(
5.0, units=detector.pixel_size_unit)
else:
detector.pixel_size.x = 5.0
detector.pixel_size.y = 5.0
# Store beam center in distance units
# Det 640 x 640 mm
if has_converter == True and \
detector.beam_center_unit != 'mm':
conv = Converter('mm')
detector.beam_center.x = conv(
center_x * 5.0,
units=detector.beam_center_unit)
detector.beam_center.y = conv(
center_y * 5.0,
units=detector.beam_center_unit)
else:
detector.beam_center.x = center_x * 5.0
detector.beam_center.y = center_y * 5.0
# Detector type
try:
detector.name = line_toks[7]
except:
# Detector name is not a mandatory entry
pass
#BCENT(X,Y) A1(mm) A2(mm) A1A2DIST(m) DL/L
# BSTOP(mm) DET_TYP
if line.count("BCENT") > 0:
is_center = True
# Parse the data
if is_data_started == True:
toks = line.split()
try:
_x = float(toks[0])
_y = float(toks[1])
_dy = float(toks[2])
_dx = float(toks[3])
if data_conv_q is not None:
_x = data_conv_q(_x, units=output.x_unit)
_dx = data_conv_i(_dx, units=output.x_unit)
if data_conv_i is not None:
_y = data_conv_i(_y, units=output.y_unit)
_dy = data_conv_i(_dy, units=output.y_unit)
x = np.append(x, _x)
y = np.append(y, _y)
dy = np.append(dy, _dy)
dx = np.append(dx, _dx)
except:
# Could not read this data line. If we are here
# it is because we are in the data section. Just
# skip it.
pass
#The 6 columns are | Q (1/A) | I(Q) (1/cm) | std. dev.
# I(Q) (1/cm) | sigmaQ | meanQ | ShadowFactor|
if line.count("The 6 columns") > 0:
is_data_started = True
# Sanity check
if not len(y) == len(dy):
msg = "abs_reader: y and dy have different length"
raise ValueError, msg
# If the data length is zero, consider this as
# though we were not able to read the file.
if len(x) == 0:
raise ValueError, "ascii_reader: could not load file"
output.x = x[x != 0]
output.y = y[x != 0]
output.dy = dy[x != 0]
output.dx = dx[x != 0]
if data_conv_q is not None:
output.xaxis("\\rm{Q}", output.x_unit)
else:
output.xaxis("\\rm{Q}", 'A^{-1}')
if data_conv_i is not None:
output.yaxis("\\rm{Intensity}", output.y_unit)
else:
output.yaxis("\\rm{Intensity}", "cm^{-1}")
# Store loading process information
output.meta_data['loader'] = self.type_name
return output
else:
raise RuntimeError, "%s is not a file" % path
return None
def _write_detectors(self, datainfo, instr):
"""
Writes the detector information to the XML file
:param datainfo: The Data1D object the information is coming from
:param inst: lxml instrument node to be appended to
"""
if datainfo.detector == None or datainfo.detector == []:
det = Detector()
det.name = ""
datainfo.detector.append(det)
for item in datainfo.detector:
det = self.create_element("SASdetector")
written = self.write_node(det, "name", item.name)
written = written | self.write_node(det, "SDD", item.distance,
{"unit": item.distance_unit})
if written == True:
self.append(det, instr)
off = self.create_element("offset")
written = self.write_node(off, "x", item.offset.x,
{"unit": item.offset_unit})
written = written | self.write_node(off, "y", item.offset.y,
{"unit": item.offset_unit})
written = written | self.write_node(off, "z", item.offset.z,
{"unit": item.offset_unit})
if written == True:
self.append(off, det)
ori = self.create_element("orientation")
written = self.write_node(ori, "roll", item.orientation.x,
{"unit": item.orientation_unit})
written = written | self.write_node(ori, "pitch",
item.orientation.y,
{"unit": item.orientation_unit})
written = written | self.write_node(ori, "yaw",
item.orientation.z,
{"unit": item.orientation_unit})
if written == True:
self.append(ori, det)
center = self.create_element("beam_center")
written = self.write_node(center, "x", item.beam_center.x,
{"unit": item.beam_center_unit})
written = written | self.write_node(center, "y",
item.beam_center.y,
{"unit": item.beam_center_unit})
written = written | self.write_node(center, "z",
item.beam_center.z,
{"unit": item.beam_center_unit})
if written == True:
self.append(center, det)
pix = self.create_element("pixel_size")
written = self.write_node(pix, "x", item.pixel_size.x,
{"unit": item.pixel_size_unit})
written = written | self.write_node(pix, "y", item.pixel_size.y,
{"unit": item.pixel_size_unit})
written = written | self.write_node(pix, "z", item.pixel_size.z,
{"unit": item.pixel_size_unit})
written = written | self.write_node(det, "slit_length",
item.slit_length,
{"unit": item.slit_length_unit})
if written == True:
self.append(pix, det)
def get_file_contents(self):
"""
Get the contents of the file
:raise RuntimeError: when the file can't be opened
:raise ValueError: when the length of the data vectors are inconsistent
"""
buff = self.f_open.read()
filepath = self.f_open.name
lines = buff.splitlines()
self.has_converter = True
try:
from sas.sascalc.data_util.nxsunit import Converter
except:
self.has_converter = False
self.output = []
self.current_datainfo = DataInfo()
self.current_datainfo.filename = filepath
self.reset_data_list(len(lines))
detector = Detector()
data_line = 0
self.reset_data_list(len(lines))
self.current_datainfo.detector.append(detector)
self.current_datainfo.filename = filepath
is_info = False
is_center = False
is_data_started = False
base_q_unit = '1/A'
base_i_unit = '1/cm'
data_conv_q = Converter(base_q_unit)
data_conv_i = Converter(base_i_unit)
for line in lines:
# Information line 1
if is_info:
is_info = False
line_toks = line.split()
# Wavelength in Angstrom
try:
value = float(line_toks[1])
if self.has_converter and \
self.current_datainfo.source.wavelength_unit != 'A':
conv = Converter('A')
self.current_datainfo.source.wavelength = conv(value,
units=self.current_datainfo.source.wavelength_unit)
else:
self.current_datainfo.source.wavelength = value
except KeyError:
msg = "ABSReader cannot read wavelength from %s" % filepath
self.current_datainfo.errors.append(msg)
# Detector distance in meters
try:
value = float(line_toks[3])
if self.has_converter and detector.distance_unit != 'm':
conv = Converter('m')
detector.distance = conv(value,
units=detector.distance_unit)
else:
detector.distance = value
except:
msg = "ABSReader cannot read SDD from %s" % filepath
self.current_datainfo.errors.append(msg)
# Transmission
try:
self.current_datainfo.sample.transmission = \
float(line_toks[4])
except ValueError:
# Transmission isn't always in the header
pass
# Sample thickness in mm
try:
value = float(line_toks[5])
if self.has_converter and \
self.current_datainfo.sample.thickness_unit != 'cm':
conv = Converter('cm')
self.current_datainfo.sample.thickness = conv(value,
units=self.current_datainfo.sample.thickness_unit)
else:
self.current_datainfo.sample.thickness = value
except ValueError:
# Thickness is not a mandatory entry
pass
# MON CNT LAMBDA DET ANG DET DIST TRANS THICK AVE STEP
if line.count("LAMBDA") > 0:
is_info = True
# Find center info line
if is_center:
is_center = False
line_toks = line.split()
# Center in bin number
center_x = float(line_toks[0])
center_y = float(line_toks[1])
# Bin size
if self.has_converter and detector.pixel_size_unit != 'mm':
conv = Converter('mm')
detector.pixel_size.x = conv(5.08,
units=detector.pixel_size_unit)
detector.pixel_size.y = conv(5.08,
units=detector.pixel_size_unit)
else:
detector.pixel_size.x = 5.08
detector.pixel_size.y = 5.08
# Store beam center in distance units
# Det 640 x 640 mm
if self.has_converter and detector.beam_center_unit != 'mm':
conv = Converter('mm')
detector.beam_center.x = conv(center_x * 5.08,
units=detector.beam_center_unit)
detector.beam_center.y = conv(center_y * 5.08,
units=detector.beam_center_unit)
else:
detector.beam_center.x = center_x * 5.08
detector.beam_center.y = center_y * 5.08
# Detector type
try:
detector.name = line_toks[7]
except:
# Detector name is not a mandatory entry
pass
# BCENT(X,Y) A1(mm) A2(mm) A1A2DIST(m) DL/L BSTOP(mm) DET_TYP
if line.count("BCENT") > 0:
is_center = True
# Parse the data
if is_data_started:
toks = line.split()
try:
_x = float(toks[0])
_y = float(toks[1])
_dy = float(toks[2])
_dx = float(toks[3])
if data_conv_q is not None:
_x = data_conv_q(_x, units=base_q_unit)
_dx = data_conv_q(_dx, units=base_q_unit)
if data_conv_i is not None:
_y = data_conv_i(_y, units=base_i_unit)
_dy = data_conv_i(_dy, units=base_i_unit)
self.current_dataset.x[data_line] = _x
self.current_dataset.y[data_line] = _y
self.current_dataset.dy[data_line] = _dy
self.current_dataset.dx[data_line] = _dx
data_line += 1
except ValueError:
# Could not read this data line. If we are here
# it is because we are in the data section. Just
# skip it.
pass
# The 6 columns are | Q (1/A) | I(Q) (1/cm) | std. dev.
# I(Q) (1/cm) | sigmaQ | meanQ | ShadowFactor|
if line.count("The 6 columns") > 0:
is_data_started = True
self.remove_empty_q_values(True, True)
# Sanity check
if not len(self.current_dataset.y) == len(self.current_dataset.dy):
self.set_all_to_none()
msg = "abs_reader: y and dy have different length"
raise ValueError(msg)
# If the data length is zero, consider this as
# though we were not able to read the file.
if len(self.current_dataset.x) == 0:
self.set_all_to_none()
raise ValueError("ascii_reader: could not load file")
if data_conv_q is not None:
self.current_dataset.xaxis("\\rm{Q}", base_q_unit)
else:
self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}')
if data_conv_i is not None:
self.current_dataset.yaxis("\\rm{Intensity}", base_i_unit)
else:
self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}")
# Store loading process information
self.current_datainfo.meta_data['loader'] = self.type_name
self.send_to_output()
def on_click_cancel(self, event):
"""
reset the current detector to its initial values
"""
self.reset_detector()
self.set_values()
if self.manager is not None:
self.manager.set_detector(self._detector)
def on_click_apply(self, event):
"""
Apply user values to the detector
"""
self.on_change_instrument()
self.on_change_distance()
self.on_change_instrument()
self.on_change_beam_center()
self.on_change_offset()
self.on_change_orientation()
self.on_change_pixel_size()
self.on_change_slit_length()
for detector in self._detector:
self.manager.set_detector(self._detector, self._notes)
if __name__ == "__main__":
app = wx.App()
test_detector = Detector()
dlg = DetectorDialog(detector=[test_detector])
dlg.ShowModal()
app.MainLoop()
def read(self, filename=None):
""" Read file """
if not os.path.isfile(filename):
raise ValueError, \
"Specified file %s is not a regular file" % filename
# Read file
f = open(filename, 'r')
buf = f.read()
# Instantiate data object
output = Data2D()
output.filename = os.path.basename(filename)
detector = Detector()
if len(output.detector) > 0:
print str(output.detector[0])
output.detector.append(detector)
# Get content
dataStarted = False
lines = buf.split('\n')
itot = 0
x = []
y = []
ncounts = 0
xmin = None
xmax = None
ymin = None
ymax = None
i_x = 0
i_y = -1
i_tot_row = 0
isInfo = False
isCenter = False
data_conv_q = None
data_conv_i = None
if has_converter == True and output.Q_unit != '1/A':
data_conv_q = Converter('1/A')
# Test it
data_conv_q(1.0, output.Q_unit)
if has_converter == True and output.I_unit != '1/cm':
data_conv_i = Converter('1/cm')
# Test it
data_conv_i(1.0, output.I_unit)
for line in lines:
# Find setup info line
if isInfo:
isInfo = False
line_toks = line.split()
# Wavelength in Angstrom
try:
wavelength = float(line_toks[1])
except:
msg = "IgorReader: can't read this file, missing wavelength"
raise ValueError, msg
#Find # of bins in a row assuming the detector is square.
if dataStarted == True:
try:
value = float(line)
except:
# Found a non-float entry, skip it
continue
# Get total bin number
i_tot_row += 1
i_tot_row = math.ceil(math.sqrt(i_tot_row)) - 1
#print "i_tot", i_tot_row
size_x = i_tot_row # 192#128
size_y = i_tot_row # 192#128
output.data = numpy.zeros([size_x, size_y])
output.err_data = numpy.zeros([size_x, size_y])
#Read Header and 2D data
for line in lines:
# Find setup info line
if isInfo:
isInfo = False
line_toks = line.split()
# Wavelength in Angstrom
try:
wavelength = float(line_toks[1])
except:
msg = "IgorReader: can't read this file, missing wavelength"
raise ValueError, msg
# Distance in meters
try:
distance = float(line_toks[3])
except:
msg = "IgorReader: can't read this file, missing distance"
raise ValueError, msg
# Distance in meters
try:
transmission = float(line_toks[4])
except:
msg = "IgorReader: can't read this file, "
msg += "missing transmission"
raise ValueError, msg
if line.count("LAMBDA") > 0:
isInfo = True
# Find center info line
if isCenter:
isCenter = False
line_toks = line.split()
# Center in bin number: Must substrate 1 because
#the index starts from 1
center_x = float(line_toks[0]) - 1
center_y = float(line_toks[1]) - 1
if line.count("BCENT") > 0:
isCenter = True
# Find data start
if line.count("***")>0:
dataStarted = True
# Check that we have all the info
if wavelength == None \
or distance == None \
or center_x == None \
or center_y == None:
msg = "IgorReader:Missing information in data file"
raise ValueError, msg
if dataStarted == True:
try:
value = float(line)
except:
# Found a non-float entry, skip it
continue
# Get bin number
if math.fmod(itot, i_tot_row) == 0:
i_x = 0
i_y += 1
else:
i_x += 1
output.data[i_y][i_x] = value
ncounts += 1
# Det 640 x 640 mm
# Q = 4pi/lambda sin(theta/2)
# Bin size is 0.5 cm
#REmoved +1 from theta = (i_x-center_x+1)*0.5 / distance
# / 100.0 and
#REmoved +1 from theta = (i_y-center_y+1)*0.5 /
# distance / 100.0
#ToDo: Need complete check if the following
# covert process is consistent with fitting.py.
theta = (i_x - center_x) * 0.5 / distance / 100.0
qx = 4.0 * math.pi / wavelength * math.sin(theta/2.0)
if has_converter == True and output.Q_unit != '1/A':
qx = data_conv_q(qx, units=output.Q_unit)
if xmin == None or qx < xmin:
xmin = qx
if xmax == None or qx > xmax:
xmax = qx
theta = (i_y - center_y) * 0.5 / distance / 100.0
qy = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
if has_converter == True and output.Q_unit != '1/A':
qy = data_conv_q(qy, units=output.Q_unit)
if ymin == None or qy < ymin:
ymin = qy
if ymax == None or qy > ymax:
ymax = qy
if not qx in x:
x.append(qx)
if not qy in y:
y.append(qy)
itot += 1
theta = 0.25 / distance / 100.0
xstep = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
theta = 0.25 / distance / 100.0
ystep = 4.0 * math.pi/ wavelength * math.sin(theta / 2.0)
# Store all data ######################################
# Store wavelength
if has_converter == True and output.source.wavelength_unit != 'A':
conv = Converter('A')
wavelength = conv(wavelength, units=output.source.wavelength_unit)
output.source.wavelength = wavelength
# Store distance
if has_converter == True and detector.distance_unit != 'm':
conv = Converter('m')
distance = conv(distance, units=detector.distance_unit)
detector.distance = distance
# Store transmission
output.sample.transmission = transmission
# Store pixel size
pixel = 5.0
if has_converter == True and detector.pixel_size_unit != 'mm':
conv = Converter('mm')
pixel = conv(pixel, units=detector.pixel_size_unit)
detector.pixel_size.x = pixel
detector.pixel_size.y = pixel
# Store beam center in distance units
detector.beam_center.x = center_x * pixel
detector.beam_center.y = center_y * pixel
# Store limits of the image (2D array)
xmin = xmin - xstep / 2.0
xmax = xmax + xstep / 2.0
ymin = ymin - ystep / 2.0
ymax = ymax + ystep / 2.0
if has_converter == True and output.Q_unit != '1/A':
xmin = data_conv_q(xmin, units=output.Q_unit)
xmax = data_conv_q(xmax, units=output.Q_unit)
ymin = data_conv_q(ymin, units=output.Q_unit)
ymax = data_conv_q(ymax, units=output.Q_unit)
output.xmin = xmin
output.xmax = xmax
output.ymin = ymin
output.ymax = ymax
# Store x and y axis bin centers
output.x_bins = x
output.y_bins = y
# Units
if data_conv_q is not None:
output.xaxis("\\rm{Q_{x}}", output.Q_unit)
output.yaxis("\\rm{Q_{y}}", output.Q_unit)
else:
output.xaxis("\\rm{Q_{x}}", 'A^{-1}')
output.yaxis("\\rm{Q_{y}}", 'A^{-1}')
if data_conv_i is not None:
output.zaxis("\\rm{Intensity}", output.I_unit)
else:
output.zaxis("\\rm{Intensity}", "cm^{-1}")
# Store loading process information
output.meta_data['loader'] = self.type_name
output = reader2D_converter(output)
return output
def read(self, filename=None):
""" Read file """
if not os.path.isfile(filename):
raise ValueError("Specified file %s is not a regular "
"file" % filename)
output = Data2D()
output.filename = os.path.basename(filename)
detector = Detector()
if len(output.detector):
print(str(output.detector[0]))
output.detector.append(detector)
data_conv_q = data_conv_i = None
if has_converter and output.Q_unit != '1/A':
data_conv_q = Converter('1/A')
# Test it
data_conv_q(1.0, output.Q_unit)
if has_converter and output.I_unit != '1/cm':
data_conv_i = Converter('1/cm')
# Test it
data_conv_i(1.0, output.I_unit)
data_row = 0
wavelength = distance = center_x = center_y = None
dataStarted = isInfo = isCenter = False
with open(filename, 'r') as f:
for line in f:
data_row += 1
# Find setup info line
if isInfo:
isInfo = False
line_toks = line.split()
# Wavelength in Angstrom
try:
wavelength = float(line_toks[1])
except ValueError:
msg = "IgorReader: can't read this file, missing wavelength"
raise ValueError(msg)
# Distance in meters
try:
distance = float(line_toks[3])
except ValueError:
msg = "IgorReader: can't read this file, missing distance"
raise ValueError(msg)
# Distance in meters
try:
transmission = float(line_toks[4])
except:
msg = "IgorReader: can't read this file, "
msg += "missing transmission"
raise ValueError(msg)
if line.count("LAMBDA"):
isInfo = True
# Find center info line
if isCenter:
isCenter = False
line_toks = line.split()
# Center in bin number: Must subtract 1 because
# the index starts from 1
center_x = float(line_toks[0]) - 1
center_y = float(line_toks[1]) - 1
if line.count("BCENT"):
isCenter = True
# Find data start
if line.count("***"):
# now have to continue to blank line
dataStarted = True
# Check that we have all the info
if (wavelength is None or distance is None
or center_x is None or center_y is None):
msg = "IgorReader:Missing information in data file"
raise ValueError(msg)
if dataStarted:
if len(line.rstrip()):
continue
else:
break
# The data is loaded in row major order (last index changing most
# rapidly). However, the original data is in column major order (first
# index changing most rapidly). The swap to column major order is done
# in reader2D_converter at the end of this method.
data = np.loadtxt(filename, skiprows=data_row)
size_x = size_y = int(np.rint(np.sqrt(data.size)))
output.data = np.reshape(data, (size_x, size_y))
output.err_data = np.zeros_like(output.data)
# Det 640 x 640 mm
# Q = 4 * pi/lambda * sin(theta/2)
# Bin size is 0.5 cm
# Removed +1 from theta = (i_x - center_x + 1)*0.5 / distance
# / 100.0 and
# Removed +1 from theta = (i_y - center_y + 1)*0.5 /
# distance / 100.0
# ToDo: Need complete check if the following
# convert process is consistent with fitting.py.
# calculate qx, qy bin centers of each pixel in the image
theta = (np.arange(size_x) - center_x) * 0.5 / distance / 100.
qx = 4 * np.pi / wavelength * np.sin(theta / 2)
theta = (np.arange(size_y) - center_y) * 0.5 / distance / 100.
qy = 4 * np.pi / wavelength * np.sin(theta / 2)
if has_converter and output.Q_unit != '1/A':
qx = data_conv_q(qx, units=output.Q_unit)
qy = data_conv_q(qx, units=output.Q_unit)
xmax = np.max(qx)
xmin = np.min(qx)
ymax = np.max(qy)
ymin = np.min(qy)
# calculate edge offset in q.
theta = 0.25 / distance / 100.0
xstep = 4.0 * np.pi / wavelength * np.sin(theta / 2.0)
theta = 0.25 / distance / 100.0
ystep = 4.0 * np.pi / wavelength * np.sin(theta / 2.0)
# Store all data ######################################
# Store wavelength
if has_converter and output.source.wavelength_unit != 'A':
conv = Converter('A')
wavelength = conv(wavelength, units=output.source.wavelength_unit)
output.source.wavelength = wavelength
# Store distance
if has_converter and detector.distance_unit != 'm':
conv = Converter('m')
distance = conv(distance, units=detector.distance_unit)
detector.distance = distance
# Store transmission
output.sample.transmission = transmission
# Store pixel size (mm)
pixel = 5.0
if has_converter and detector.pixel_size_unit != 'mm':
conv = Converter('mm')
pixel = conv(pixel, units=detector.pixel_size_unit)
detector.pixel_size.x = pixel
detector.pixel_size.y = pixel
# Store beam center in distance units
detector.beam_center.x = center_x * pixel
detector.beam_center.y = center_y * pixel
# Store limits of the image (2D array)
xmin -= xstep / 2.0
xmax += xstep / 2.0
ymin -= ystep / 2.0
ymax += ystep / 2.0
if has_converter and output.Q_unit != '1/A':
xmin = data_conv_q(xmin, units=output.Q_unit)
xmax = data_conv_q(xmax, units=output.Q_unit)
ymin = data_conv_q(ymin, units=output.Q_unit)
ymax = data_conv_q(ymax, units=output.Q_unit)
output.xmin = xmin
output.xmax = xmax
output.ymin = ymin
output.ymax = ymax
# Store x and y axis bin centers
output.x_bins = qx.tolist()
output.y_bins = qy.tolist()
# Units
if data_conv_q is not None:
output.xaxis("\\rm{Q_{x}}", output.Q_unit)
output.yaxis("\\rm{Q_{y}}", output.Q_unit)
else:
output.xaxis("\\rm{Q_{x}}", 'A^{-1}')
output.yaxis("\\rm{Q_{y}}", 'A^{-1}')
if data_conv_i is not None:
output.zaxis("\\rm{Intensity}", output.I_unit)
else:
output.zaxis("\\rm{Intensity}", "cm^{-1}")
# Store loading process information
output.meta_data['loader'] = self.type_name
output = reader2D_converter(output)
return output
def read(self, filename=None):
""" Read file """
if not os.path.isfile(filename):
raise ValueError, \
"Specified file %s is not a regular file" % filename
# Read file
f = open(filename, 'r')
buf = f.read()
f.close()
# Instantiate data object
output = Data2D()
output.filename = os.path.basename(filename)
detector = Detector()
if len(output.detector) > 0:
print(str(output.detector[0]))
output.detector.append(detector)
# Get content
dataStarted = False
## Defaults
lines = buf.split('\n')
x = []
y = []
wavelength = None
distance = None
transmission = None
pixel_x = None
pixel_y = None
isInfo = False
isCenter = False
data_conv_q = None
data_conv_i = None
# Set units: This is the unit assumed for Q and I in the data file.
if has_converter == True and output.Q_unit != '1/A':
data_conv_q = Converter('1/A')
# Test it
data_conv_q(1.0, output.Q_unit)
if has_converter == True and output.I_unit != '1/cm':
data_conv_i = Converter('1/cm')
# Test it
data_conv_i(1.0, output.I_unit)
# Remove the last lines before the for loop if the lines are empty
# to calculate the exact number of data points
count = 0
while (len(lines[len(lines) - (count + 1)].lstrip().rstrip()) < 1):
del lines[len(lines) - (count + 1)]
count = count + 1
#Read Header and find the dimensions of 2D data
line_num = 0
# Old version NIST files: 0
ver = 0
for line in lines:
line_num += 1
## Reading the header applies only to IGOR/NIST 2D q_map data files
# Find setup info line
if isInfo:
isInfo = False
line_toks = line.split()
# Wavelength in Angstrom
try:
wavelength = float(line_toks[1])
# Units
if has_converter == True and \
output.source.wavelength_unit != 'A':
conv = Converter('A')
wavelength = conv(wavelength,
units=output.source.wavelength_unit)
except:
#Not required
pass
# Distance in mm
try:
distance = float(line_toks[3])
# Units
if has_converter == True and detector.distance_unit != 'm':
conv = Converter('m')
distance = conv(distance, units=detector.distance_unit)
except:
#Not required
pass
# Distance in meters
try:
transmission = float(line_toks[4])
except:
#Not required
pass
if line.count("LAMBDA") > 0:
isInfo = True
# Find center info line
if isCenter:
isCenter = False
line_toks = line.split()
# Center in bin number
center_x = float(line_toks[0])
center_y = float(line_toks[1])
if line.count("BCENT") > 0:
isCenter = True
# Check version
if line.count("Data columns") > 0:
if line.count("err(I)") > 0:
ver = 1
# Find data start
if line.count("ASCII data") > 0:
dataStarted = True
continue
## Read and get data.
if dataStarted == True:
line_toks = line.split()
if len(line_toks) == 0:
#empty line
continue
# the number of columns must be stayed same
col_num = len(line_toks)
break
# Make numpy array to remove header lines using index
lines_array = np.array(lines)
# index for lines_array
lines_index = np.arange(len(lines))
# get the data lines
data_lines = lines_array[lines_index >= (line_num - 1)]
# Now we get the total number of rows (i.e., # of data points)
row_num = len(data_lines)
# make it as list again to control the separators
data_list = " ".join(data_lines.tolist())
# split all data to one big list w/" "separator
data_list = data_list.split()
# Check if the size is consistent with data, otherwise
#try the tab(\t) separator
# (this may be removed once get the confidence
#the former working all cases).
if len(data_list) != (len(data_lines)) * col_num:
data_list = "\t".join(data_lines.tolist())
data_list = data_list.split()
# Change it(string) into float
#data_list = map(float,data_list)
data_list1 = map(check_point, data_list)
# numpy array form
data_array = np.array(data_list1)
# Redimesion based on the row_num and col_num,
#otherwise raise an error.
try:
data_point = data_array.reshape(row_num, col_num).transpose()
except:
msg = "red2d_reader: Can't read this file: Not a proper file format"
raise ValueError, msg
## Get the all data: Let's HARDcoding; Todo find better way
# Defaults
dqx_data = np.zeros(0)
dqy_data = np.zeros(0)
err_data = np.ones(row_num)
qz_data = np.zeros(row_num)
mask = np.ones(row_num, dtype=bool)
# Get from the array
qx_data = data_point[0]
qy_data = data_point[1]
data = data_point[2]
if ver == 1:
if col_num > (2 + ver):
err_data = data_point[(2 + ver)]
if col_num > (3 + ver):
qz_data = data_point[(3 + ver)]
if col_num > (4 + ver):
dqx_data = data_point[(4 + ver)]
if col_num > (5 + ver):
dqy_data = data_point[(5 + ver)]
#if col_num > (6 + ver): mask[data_point[(6 + ver)] < 1] = False
q_data = np.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data)
# Extra protection(it is needed for some data files):
# If all mask elements are False, put all True
if not mask.any():
mask[mask == False] = True
# Store limits of the image in q space
xmin = np.min(qx_data)
xmax = np.max(qx_data)
ymin = np.min(qy_data)
ymax = np.max(qy_data)
# units
if has_converter == True and output.Q_unit != '1/A':
xmin = data_conv_q(xmin, units=output.Q_unit)
xmax = data_conv_q(xmax, units=output.Q_unit)
ymin = data_conv_q(ymin, units=output.Q_unit)
ymax = data_conv_q(ymax, units=output.Q_unit)
## calculate the range of the qx and qy_data
x_size = math.fabs(xmax - xmin)
y_size = math.fabs(ymax - ymin)
# calculate the number of pixels in the each axes
npix_y = math.floor(math.sqrt(len(data)))
npix_x = math.floor(len(data) / npix_y)
# calculate the size of bins
xstep = x_size / (npix_x - 1)
ystep = y_size / (npix_y - 1)
# store x and y axis bin centers in q space
x_bins = np.arange(xmin, xmax + xstep, xstep)
y_bins = np.arange(ymin, ymax + ystep, ystep)
# get the limits of q values
xmin = xmin - xstep / 2
xmax = xmax + xstep / 2
ymin = ymin - ystep / 2
ymax = ymax + ystep / 2
#Store data in outputs
#TODO: Check the lengths
output.data = data
if (err_data == 1).all():
output.err_data = np.sqrt(np.abs(data))
output.err_data[output.err_data == 0.0] = 1.0
else:
output.err_data = err_data
output.qx_data = qx_data
output.qy_data = qy_data
output.q_data = q_data
output.mask = mask
output.x_bins = x_bins
output.y_bins = y_bins
output.xmin = xmin
output.xmax = xmax
output.ymin = ymin
output.ymax = ymax
output.source.wavelength = wavelength
# Store pixel size in mm
detector.pixel_size.x = pixel_x
detector.pixel_size.y = pixel_y
# Store the sample to detector distance
detector.distance = distance
# optional data: if all of dq data == 0, do not pass to output
if len(dqx_data) == len(qx_data) and dqx_data.any() != 0:
# if no dqx_data, do not pass dqy_data.
#(1 axis dq is not supported yet).
if len(dqy_data) == len(qy_data) and dqy_data.any() != 0:
# Currently we do not support dq parr, perp.
# tranfer the comp. to cartesian coord. for newer version.
if ver != 1:
diag = np.sqrt(qx_data * qx_data + qy_data * qy_data)
cos_th = qx_data / diag
sin_th = qy_data / diag
output.dqx_data = np.sqrt((dqx_data * cos_th) * \
(dqx_data * cos_th) \
+ (dqy_data * sin_th) * \
(dqy_data * sin_th))
output.dqy_data = np.sqrt((dqx_data * sin_th) * \
(dqx_data * sin_th) \
+ (dqy_data * cos_th) * \
(dqy_data * cos_th))
else:
output.dqx_data = dqx_data
output.dqy_data = dqy_data
# Units of axes
if data_conv_q is not None:
output.xaxis("\\rm{Q_{x}}", output.Q_unit)
output.yaxis("\\rm{Q_{y}}", output.Q_unit)
else:
output.xaxis("\\rm{Q_{x}}", 'A^{-1}')
output.yaxis("\\rm{Q_{y}}", 'A^{-1}')
if data_conv_i is not None:
output.zaxis("\\rm{Intensity}", output.I_unit)
else:
output.zaxis("\\rm{Intensity}", "cm^{-1}")
# Store loading process information
output.meta_data['loader'] = self.type_name
return output
def read(self, path):
"""
Load data file.
:param path: file path
:return: Data1D object, or None
:raise RuntimeError: when the file can't be opened
:raise ValueError: when the length of the data vectors are inconsistent
"""
if os.path.isfile(path):
basename = os.path.basename(path)
root, extension = os.path.splitext(basename)
if extension.lower() in self.ext:
try:
input_f = open(path,'r')
except:
raise RuntimeError, "abs_reader: cannot open %s" % path
buff = input_f.read()
lines = buff.split('\n')
x = numpy.zeros(0)
y = numpy.zeros(0)
dy = numpy.zeros(0)
dx = numpy.zeros(0)
output = Data1D(x, y, dy=dy, dx=dx)
detector = Detector()
output.detector.append(detector)
output.filename = basename
is_info = False
is_center = False
is_data_started = False
data_conv_q = None
data_conv_i = None
if has_converter == True and output.x_unit != '1/A':
data_conv_q = Converter('1/A')
# Test it
data_conv_q(1.0, output.x_unit)
if has_converter == True and output.y_unit != '1/cm':
data_conv_i = Converter('1/cm')
# Test it
data_conv_i(1.0, output.y_unit)
for line in lines:
# Information line 1
if is_info == True:
is_info = False
line_toks = line.split()
# Wavelength in Angstrom
try:
value = float(line_toks[1])
if has_converter == True and \
output.source.wavelength_unit != 'A':
conv = Converter('A')
output.source.wavelength = conv(value,
units=output.source.wavelength_unit)
else:
output.source.wavelength = value
except:
#goes to ASC reader
msg = "abs_reader: cannot open %s" % path
raise RuntimeError, msg
# Distance in meters
try:
value = float(line_toks[3])
if has_converter == True and \
detector.distance_unit != 'm':
conv = Converter('m')
detector.distance = conv(value,
units=detector.distance_unit)
else:
detector.distance = value
except:
#goes to ASC reader
msg = "abs_reader: cannot open %s" % path
raise RuntimeError, msg
# Transmission
try:
output.sample.transmission = float(line_toks[4])
except:
# Transmission is not a mandatory entry
pass
# Thickness in mm
try:
value = float(line_toks[5])
if has_converter == True and \
output.sample.thickness_unit != 'cm':
conv = Converter('cm')
output.sample.thickness = conv(value,
units=output.sample.thickness_unit)
else:
output.sample.thickness = value
except:
# Thickness is not a mandatory entry
pass
#MON CNT LAMBDA DET ANG DET DIST TRANS THICK
# AVE STEP
if line.count("LAMBDA") > 0:
is_info = True
# Find center info line
if is_center == True:
is_center = False
line_toks = line.split()
# Center in bin number
center_x = float(line_toks[0])
center_y = float(line_toks[1])
# Bin size
if has_converter == True and \
detector.pixel_size_unit != 'mm':
conv = Converter('mm')
detector.pixel_size.x = conv(5.0,
units=detector.pixel_size_unit)
detector.pixel_size.y = conv(5.0,
units=detector.pixel_size_unit)
else:
detector.pixel_size.x = 5.0
detector.pixel_size.y = 5.0
# Store beam center in distance units
# Det 640 x 640 mm
if has_converter == True and \
detector.beam_center_unit != 'mm':
conv = Converter('mm')
detector.beam_center.x = conv(center_x * 5.0,
units=detector.beam_center_unit)
detector.beam_center.y = conv(center_y * 5.0,
units=detector.beam_center_unit)
else:
detector.beam_center.x = center_x * 5.0
detector.beam_center.y = center_y * 5.0
# Detector type
try:
detector.name = line_toks[7]
except:
# Detector name is not a mandatory entry
pass
#BCENT(X,Y) A1(mm) A2(mm) A1A2DIST(m) DL/L
# BSTOP(mm) DET_TYP
if line.count("BCENT") > 0:
is_center = True
# Parse the data
if is_data_started == True:
toks = line.split()
try:
_x = float(toks[0])
_y = float(toks[1])
_dy = float(toks[2])
_dx = float(toks[3])
if data_conv_q is not None:
_x = data_conv_q(_x, units=output.x_unit)
_dx = data_conv_i(_dx, units=output.x_unit)
if data_conv_i is not None:
_y = data_conv_i(_y, units=output.y_unit)
_dy = data_conv_i(_dy, units=output.y_unit)
x = numpy.append(x, _x)
y = numpy.append(y, _y)
dy = numpy.append(dy, _dy)
dx = numpy.append(dx, _dx)
except:
# Could not read this data line. If we are here
# it is because we are in the data section. Just
# skip it.
pass
#The 6 columns are | Q (1/A) | I(Q) (1/cm) | std. dev.
# I(Q) (1/cm) | sigmaQ | meanQ | ShadowFactor|
if line.count("The 6 columns") > 0:
is_data_started = True
# Sanity check
if not len(y) == len(dy):
msg = "abs_reader: y and dy have different length"
raise ValueError, msg
# If the data length is zero, consider this as
# though we were not able to read the file.
if len(x) == 0:
raise ValueError, "ascii_reader: could not load file"
output.x = x[x != 0]
output.y = y[x != 0]
output.dy = dy[x != 0]
output.dx = dx[x != 0]
if data_conv_q is not None:
output.xaxis("\\rm{Q}", output.x_unit)
else:
output.xaxis("\\rm{Q}", 'A^{-1}')
if data_conv_i is not None:
output.yaxis("\\rm{Intensity}", output.y_unit)
else:
output.yaxis("\\rm{Intensity}", "cm^{-1}")
# Store loading process information
output.meta_data['loader'] = self.type_name
return output
else:
raise RuntimeError, "%s is not a file" % path
return None
def read(self, filename=None):
""" Read file """
if not os.path.isfile(filename):
raise ValueError("Specified file %s is not a regular "
"file" % filename)
output = Data2D()
output.filename = os.path.basename(filename)
detector = Detector()
if len(output.detector):
print(str(output.detector[0]))
output.detector.append(detector)
data_conv_q = data_conv_i = None
if has_converter and output.Q_unit != '1/A':
data_conv_q = Converter('1/A')
# Test it
data_conv_q(1.0, output.Q_unit)
if has_converter and output.I_unit != '1/cm':
data_conv_i = Converter('1/cm')
# Test it
data_conv_i(1.0, output.I_unit)
data_row = 0
wavelength = distance = center_x = center_y = None
dataStarted = isInfo = isCenter = False
with open(filename, 'r') as f:
for line in f:
data_row += 1
# Find setup info line
if isInfo:
isInfo = False
line_toks = line.split()
# Wavelength in Angstrom
try:
wavelength = float(line_toks[1])
except ValueError:
msg = "IgorReader: can't read this file, missing wavelength"
raise ValueError(msg)
# Distance in meters
try:
distance = float(line_toks[3])
except ValueError:
msg = "IgorReader: can't read this file, missing distance"
raise ValueError(msg)
# Distance in meters
try:
transmission = float(line_toks[4])
except:
msg = "IgorReader: can't read this file, "
msg += "missing transmission"
raise ValueError(msg)
if line.count("LAMBDA"):
isInfo = True
# Find center info line
if isCenter:
isCenter = False
line_toks = line.split()
# Center in bin number: Must subtract 1 because
# the index starts from 1
center_x = float(line_toks[0]) - 1
center_y = float(line_toks[1]) - 1
if line.count("BCENT"):
isCenter = True
# Find data start
if line.count("***"):
# now have to continue to blank line
dataStarted = True
# Check that we have all the info
if (wavelength is None
or distance is None
or center_x is None
or center_y is None):
msg = "IgorReader:Missing information in data file"
raise ValueError(msg)
if dataStarted:
if len(line.rstrip()):
continue
else:
break
# The data is loaded in row major order (last index changing most
# rapidly). However, the original data is in column major order (first
# index changing most rapidly). The swap to column major order is done
# in reader2D_converter at the end of this method.
data = np.loadtxt(filename, skiprows=data_row)
size_x = size_y = int(np.rint(np.sqrt(data.size)))
output.data = np.reshape(data, (size_x, size_y))
output.err_data = np.zeros_like(output.data)
# Det 640 x 640 mm
# Q = 4 * pi/lambda * sin(theta/2)
# Bin size is 0.5 cm
# Removed +1 from theta = (i_x - center_x + 1)*0.5 / distance
# / 100.0 and
# Removed +1 from theta = (i_y - center_y + 1)*0.5 /
# distance / 100.0
# ToDo: Need complete check if the following
# convert process is consistent with fitting.py.
# calculate qx, qy bin centers of each pixel in the image
theta = (np.arange(size_x) - center_x) * 0.5 / distance / 100.
qx = 4 * np.pi / wavelength * np.sin(theta/2)
theta = (np.arange(size_y) - center_y) * 0.5 / distance / 100.
qy = 4 * np.pi / wavelength * np.sin(theta/2)
if has_converter and output.Q_unit != '1/A':
qx = data_conv_q(qx, units=output.Q_unit)
qy = data_conv_q(qx, units=output.Q_unit)
xmax = np.max(qx)
xmin = np.min(qx)
ymax = np.max(qy)
ymin = np.min(qy)
# calculate edge offset in q.
theta = 0.25 / distance / 100.0
xstep = 4.0 * np.pi / wavelength * np.sin(theta / 2.0)
theta = 0.25 / distance / 100.0
ystep = 4.0 * np.pi/ wavelength * np.sin(theta / 2.0)
# Store all data ######################################
# Store wavelength
if has_converter and output.source.wavelength_unit != 'A':
conv = Converter('A')
wavelength = conv(wavelength, units=output.source.wavelength_unit)
output.source.wavelength = wavelength
# Store distance
if has_converter and detector.distance_unit != 'm':
conv = Converter('m')
distance = conv(distance, units=detector.distance_unit)
detector.distance = distance
# Store transmission
output.sample.transmission = transmission
# Store pixel size (mm)
pixel = 5.0
if has_converter and detector.pixel_size_unit != 'mm':
conv = Converter('mm')
pixel = conv(pixel, units=detector.pixel_size_unit)
detector.pixel_size.x = pixel
detector.pixel_size.y = pixel
# Store beam center in distance units
detector.beam_center.x = center_x * pixel
detector.beam_center.y = center_y * pixel
# Store limits of the image (2D array)
xmin -= xstep / 2.0
xmax += xstep / 2.0
ymin -= ystep / 2.0
ymax += ystep / 2.0
if has_converter and output.Q_unit != '1/A':
xmin = data_conv_q(xmin, units=output.Q_unit)
xmax = data_conv_q(xmax, units=output.Q_unit)
ymin = data_conv_q(ymin, units=output.Q_unit)
ymax = data_conv_q(ymax, units=output.Q_unit)
output.xmin = xmin
output.xmax = xmax
output.ymin = ymin
output.ymax = ymax
# Store x and y axis bin centers
output.x_bins = qx.tolist()
output.y_bins = qy.tolist()
# Units
if data_conv_q is not None:
output.xaxis("\\rm{Q_{x}}", output.Q_unit)
output.yaxis("\\rm{Q_{y}}", output.Q_unit)
else:
output.xaxis("\\rm{Q_{x}}", 'A^{-1}')
output.yaxis("\\rm{Q_{y}}", 'A^{-1}')
if data_conv_i is not None:
output.zaxis("\\rm{Intensity}", output.I_unit)
else:
output.zaxis("\\rm{Intensity}", "cm^{-1}")
# Store loading process information
output.meta_data['loader'] = self.type_name
output = reader2D_converter(output)
return output
def read(self, filename=None):
"""
Open and read the data in a file
@param file: path of the file
"""
read_it = False
for item in self.ext:
if filename.lower().find(item) >= 0:
read_it = True
if read_it:
try:
datafile = open(filename, 'r')
except:
raise RuntimeError, "danse_reader cannot open %s" % (filename)
# defaults
# wavelength in Angstrom
wavelength = 10.0
# Distance in meter
distance = 11.0
# Pixel number of center in x
center_x = 65
# Pixel number of center in y
center_y = 65
# Pixel size [mm]
pixel = 5.0
# Size in x, in pixels
size_x = 128
# Size in y, in pixels
size_y = 128
# Format version
fversion = 1.0
output = Data2D()
output.filename = os.path.basename(filename)
detector = Detector()
output.detector.append(detector)
output.data = numpy.zeros([size_x, size_y])
output.err_data = numpy.zeros([size_x, size_y])
data_conv_q = None
data_conv_i = None
if has_converter == True and output.Q_unit != '1/A':
data_conv_q = Converter('1/A')
# Test it
data_conv_q(1.0, output.Q_unit)
if has_converter == True and output.I_unit != '1/cm':
data_conv_i = Converter('1/cm')
# Test it
data_conv_i(1.0, output.I_unit)
read_on = True
while read_on:
line = datafile.readline()
if line.find("DATA:") >= 0:
read_on = False
break
toks = line.split(':')
if toks[0] == "FORMATVERSION":
fversion = float(toks[1])
if toks[0] == "WAVELENGTH":
wavelength = float(toks[1])
elif toks[0] == "DISTANCE":
distance = float(toks[1])
elif toks[0] == "CENTER_X":
center_x = float(toks[1])
elif toks[0] == "CENTER_Y":
center_y = float(toks[1])
elif toks[0] == "PIXELSIZE":
pixel = float(toks[1])
elif toks[0] == "SIZE_X":
size_x = int(toks[1])
elif toks[0] == "SIZE_Y":
size_y = int(toks[1])
# Read the data
data = []
error = []
if fversion == 1.0:
data_str = datafile.readline()
data = data_str.split(' ')
else:
read_on = True
while read_on:
data_str = datafile.readline()
if len(data_str) == 0:
read_on = False
else:
toks = data_str.split()
try:
val = float(toks[0])
err = float(toks[1])
if data_conv_i is not None:
val = data_conv_i(val, units=output._yunit)
err = data_conv_i(err, units=output._yunit)
data.append(val)
error.append(err)
except:
logging.info("Skipping line:%s,%s" %
(data_str, sys.exc_value))
# Initialize
x_vals = []
y_vals = []
ymin = None
ymax = None
xmin = None
xmax = None
# Qx and Qy vectors
theta = pixel / distance / 100.0
stepq = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
for i_x in range(size_x):
theta = (i_x - center_x + 1) * pixel / distance / 100.0
qx = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
if has_converter == True and output.Q_unit != '1/A':
qx = data_conv_q(qx, units=output.Q_unit)
x_vals.append(qx)
if xmin == None or qx < xmin:
xmin = qx
if xmax == None or qx > xmax:
xmax = qx
ymin = None
ymax = None
for i_y in range(size_y):
theta = (i_y - center_y + 1) * pixel / distance / 100.0
qy = 4.0 * math.pi / wavelength * math.sin(theta / 2.0)
if has_converter == True and output.Q_unit != '1/A':
qy = data_conv_q(qy, units=output.Q_unit)
y_vals.append(qy)
if ymin == None or qy < ymin:
ymin = qy
if ymax == None or qy > ymax:
ymax = qy
# Store the data in the 2D array
i_x = 0
i_y = -1
for i_pt in range(len(data)):
try:
value = float(data[i_pt])
except:
# For version 1.0, the data were still
# stored as strings at this point.
msg = "Skipping entry (v1.0):%s,%s" % (str(
data[i_pt]), sys.exc_value)
logging.info(msg)
# Get bin number
if math.fmod(i_pt, size_x) == 0:
i_x = 0
i_y += 1
else:
i_x += 1
output.data[i_y][i_x] = value
if fversion > 1.0:
output.err_data[i_y][i_x] = error[i_pt]
# Store all data
# Store wavelength
if has_converter == True and output.source.wavelength_unit != 'A':
conv = Converter('A')
wavelength = conv(wavelength,
units=output.source.wavelength_unit)
output.source.wavelength = wavelength
# Store distance
if has_converter == True and detector.distance_unit != 'm':
conv = Converter('m')
distance = conv(distance, units=detector.distance_unit)
detector.distance = distance
# Store pixel size
if has_converter == True and detector.pixel_size_unit != 'mm':
conv = Converter('mm')
pixel = conv(pixel, units=detector.pixel_size_unit)
detector.pixel_size.x = pixel
detector.pixel_size.y = pixel
# Store beam center in distance units
detector.beam_center.x = center_x * pixel
detector.beam_center.y = center_y * pixel
# Store limits of the image (2D array)
xmin = xmin - stepq / 2.0
xmax = xmax + stepq / 2.0
ymin = ymin - stepq / 2.0
ymax = ymax + stepq / 2.0
if has_converter == True and output.Q_unit != '1/A':
xmin = data_conv_q(xmin, units=output.Q_unit)
xmax = data_conv_q(xmax, units=output.Q_unit)
ymin = data_conv_q(ymin, units=output.Q_unit)
ymax = data_conv_q(ymax, units=output.Q_unit)
output.xmin = xmin
output.xmax = xmax
output.ymin = ymin
output.ymax = ymax
# Store x and y axis bin centers
output.x_bins = x_vals
output.y_bins = y_vals
# Units
if data_conv_q is not None:
output.xaxis("\\rm{Q_{x}}", output.Q_unit)
output.yaxis("\\rm{Q_{y}}", output.Q_unit)
else:
output.xaxis("\\rm{Q_{x}}", 'A^{-1}')
output.yaxis("\\rm{Q_{y}}", 'A^{-1}')
if data_conv_i is not None:
output.zaxis("\\rm{Intensity}", output.I_unit)
else:
output.zaxis("\\rm{Intensity}", "cm^{-1}")
if not fversion >= 1.0:
msg = "Danse_reader can't read this file %s" % filename
raise ValueError, msg
else:
logging.info("Danse_reader Reading %s \n" % filename)
# Store loading process information
output.meta_data['loader'] = self.type_name
output = reader2D_converter(output)
return output
return None
def get_file_contents(self):
self.current_datainfo = DataInfo()
self.current_dataset = plottable_2D()
self.output = []
loaded_correctly = True
error_message = ""
# defaults
# wavelength in Angstrom
wavelength = 10.0
# Distance in meter
distance = 11.0
# Pixel number of center in x
center_x = 65
# Pixel number of center in y
center_y = 65
# Pixel size [mm]
pixel = 5.0
# Size in x, in pixels
size_x = 128
# Size in y, in pixels
size_y = 128
# Format version
fversion = 1.0
self.current_datainfo.filename = os.path.basename(self.f_open.name)
detector = Detector()
self.current_datainfo.detector.append(detector)
self.current_dataset.data = np.zeros([size_x, size_y])
self.current_dataset.err_data = np.zeros([size_x, size_y])
read_on = True
data_start_line = 1
while read_on:
line = self.f_open.readline()
data_start_line += 1
if line.find("DATA:") >= 0:
read_on = False
break
toks = line.split(':')
try:
if toks[0] == "FORMATVERSION":
fversion = float(toks[1])
elif toks[0] == "WAVELENGTH":
wavelength = float(toks[1])
elif toks[0] == "DISTANCE":
distance = float(toks[1])
elif toks[0] == "CENTER_X":
center_x = float(toks[1])
elif toks[0] == "CENTER_Y":
center_y = float(toks[1])
elif toks[0] == "PIXELSIZE":
pixel = float(toks[1])
elif toks[0] == "SIZE_X":
size_x = int(toks[1])
elif toks[0] == "SIZE_Y":
size_y = int(toks[1])
except ValueError as e:
error_message += "Unable to parse {}. Default value used.\n".format(toks[0])
loaded_correctly = False
# Read the data
data = []
error = []
if not fversion >= 1.0:
msg = "danse_reader can't read this file {}".format(self.f_open.name)
raise FileContentsException(msg)
for line_num, data_str in enumerate(self.f_open.readlines()):
toks = data_str.split()
try:
val = float(toks[0])
err = float(toks[1])
data.append(val)
error.append(err)
except ValueError as exc:
msg = "Unable to parse line {}: {}".format(line_num + data_start_line, data_str.strip())
raise FileContentsException(msg)
num_pts = size_x * size_y
if len(data) < num_pts:
msg = "Not enough data points provided. Expected {} but got {}".format(
size_x * size_y, len(data))
raise FileContentsException(msg)
elif len(data) > num_pts:
error_message += ("Too many data points provided. Expected {0} but"
" got {1}. Only the first {0} will be used.\n").format(num_pts, len(data))
loaded_correctly = False
data = data[:num_pts]
error = error[:num_pts]
# Qx and Qy vectors
theta = pixel / distance / 100.0
i_x = np.arange(size_x)
theta = (i_x - center_x + 1) * pixel / distance / 100.0
x_vals = 4.0 * np.pi / wavelength * np.sin(theta / 2.0)
xmin = x_vals.min()
xmax = x_vals.max()
i_y = np.arange(size_y)
theta = (i_y - center_y + 1) * pixel / distance / 100.0
y_vals = 4.0 * np.pi / wavelength * np.sin(theta / 2.0)
ymin = y_vals.min()
ymax = y_vals.max()
self.current_dataset.data = np.array(data, dtype=np.float64).reshape((size_y, size_x))
if fversion > 1.0:
self.current_dataset.err_data = np.array(error, dtype=np.float64).reshape((size_y, size_x))
# Store all data
# Store wavelength
if has_converter == True and self.current_datainfo.source.wavelength_unit != 'A':
conv = Converter('A')
wavelength = conv(wavelength,
units=self.current_datainfo.source.wavelength_unit)
self.current_datainfo.source.wavelength = wavelength
# Store distance
if has_converter == True and detector.distance_unit != 'm':
conv = Converter('m')
distance = conv(distance, units=detector.distance_unit)
detector.distance = distance
# Store pixel size
if has_converter == True and detector.pixel_size_unit != 'mm':
conv = Converter('mm')
pixel = conv(pixel, units=detector.pixel_size_unit)
detector.pixel_size.x = pixel
detector.pixel_size.y = pixel
# Store beam center in distance units
detector.beam_center.x = center_x * pixel
detector.beam_center.y = center_y * pixel
self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}')
self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}')
self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}")
self.current_dataset.x_bins = x_vals
self.current_dataset.y_bins = y_vals
# Reshape data
x_vals = np.tile(x_vals, (size_y, 1)).flatten()
y_vals = np.tile(y_vals, (size_x, 1)).T.flatten()
if (np.all(self.current_dataset.err_data == None)
or np.any(self.current_dataset.err_data <= 0)):
new_err_data = np.sqrt(np.abs(self.current_dataset.data))
else:
new_err_data = self.current_dataset.err_data.flatten()
self.current_dataset.err_data = new_err_data
self.current_dataset.qx_data = x_vals
self.current_dataset.qy_data = y_vals
self.current_dataset.q_data = np.sqrt(x_vals**2 + y_vals**2)
self.current_dataset.mask = np.ones(len(x_vals), dtype=bool)
# Store loading process information
self.current_datainfo.meta_data['loader'] = self.type_name
self.send_to_output()
if not loaded_correctly:
raise DataReaderException(error_message)