def test_plot_export(self):
data = XYData(name="test",
x_data=arange(20),
y_data=arange(20),
x_metadata={"units": "min"},
y_metadata={"units": "AU"})
filepath = "test.png"
with temp_fname(filepath):
data.mpl_show(filepath=filepath)
self.assertIn(filepath, listdir("."))
def setUp(self):
# Build a fake peak
x = range(5)
y = [0., 1., 2., 1., 0.]
self.data = XYData(x_data=x,
y_data=y,
name="sample data",
x_metadata={"units": "seconds"})
# Build a fake double peak
x = range(10)
y = [0., 1., 2., 1., 0., 0., 1., 2., 1., 0.]
self.data_2peaks = XYData(x_data=x,
y_data=y,
name="sample data",
x_metadata={"units": "seconds"})
self.step_start = UnitScalar(0 / 60., units="minute")
self.step_stop = UnitScalar(4 / 60., units="minute")
def setUp(self):
#: Build a fake peak:
# times is in seconds
x = range(5)
y = [0., 1., 2., 1., 0.]
self.data = XYData(x_data=x, y_data=y, name="sample data")
column_type = ColumnType(**COLUMN_TYPE_DATA)
resin = Resin(**RESIN_DATA)
self.column = Column(column_type=column_type,
resin=resin,
**COLUMN_DATA)
self.column.volume = UnitScalar(100., units="liter")
def continuous_data_from_akta(import_settings, target_experiment):
""" Utility to load/transform AKTA data from settings dict, and target exp.
Parameters
----------
import_settings : dict
AKTA file import settings.
target_experiment : Experiment
Target experiment for which AKTA file contains data. Used to shift the
data by the hold up volume.
Returns
-------
dict
Dict mapping data type to XYData storing traces.
"""
continuous_data = {}
# AKTA reader applies the truncation of the data for every point before the
# time of origin:
akta_reader = AKTAReader(
file_path=import_settings["akta_fname"],
time_of_origin=float(import_settings["time_of_origin"]),
col_name_patterns=import_settings["col_name_patterns"]
)
header_info = akta_reader.header_info
for key in akta_reader.available_dataset_types:
time_key = 'time_' + key
cont_data = XYData(
name=key,
x_data=akta_reader.get_data([time_key])[time_key],
x_metadata=header_info[time_key],
y_data=akta_reader.get_data([key])[key],
y_metadata=header_info[key],
)
continuous_data[key] = cont_data
# Modify results to shift output data by the holdup volume
offset = shift_continuous_data_by_holdup_vol(continuous_data,
target_experiment)
# Record volume used:
import_settings["holdup_volume"] = offset
return continuous_data
def read_continuous_data_from_cadet_h5(output_fname, product, step_names):
""" Returns a dictionary of output data found in the provided.
Parameters
----------
output_fname : str
Path to the HDF5 file produced by CADET.
product : Product
Product this file is modeling.
step_names : list(str)
List of the step/section names.
"""
output_data = read_from_h5(output_fname, root='/output/solution')
input_data = read_from_h5(output_fname, root='/input')
bind_type = input_data["adsorption_type"]
continuous_data = {}
# The timestamps for the simulation correspond to the CADET output
# timestamps
solution_timestamps = output_data['solution_times']
# FIXME: should x_data be copied for each data entry ?
# FIXME: should we create UnitArrays ?
x_data = solution_timestamps
x_metadata = {
'name': 'time',
'units': 's',
'source': 'simulation',
}
# Read in 1D component chromatograms --------------------------------------
data_shape = input_data['number_user_solution_points']
total_conc = np.zeros(data_shape)
key_fmt = 'solution_column_outlet_comp_{:03d}'
# These are CADET binding model types, not Reveal:
if bind_type in ['STERIC_MASS_ACTION', 'EXTERNAL_STERIC_MASS_ACTION_PH']:
# Read in cation concentration
cation_conc = output_data[key_fmt.format(0)]
y_metadata = {
'name': 'cation_Sim',
'type': 'cation',
'source': 'simulation',
'units': 'mM'
}
continuous_data['cation_Sim'] = XYData(name='cation_Sim',
x_data=x_data,
x_metadata=x_metadata,
y_data=cation_conc,
y_metadata=y_metadata)
offset = 1
else:
offset = 0
# Read in product concentrations:
for ii, comp in enumerate(product.product_components):
comp_name = comp.name
molecular_weight = comp.molecular_weight[()]
ext_coeff = comp.extinction_coefficient[()]
name = comp_name + '_Sim'
y_metadata = {
'name': name,
'type': 'chromatogram',
'source': 'simulation',
'units': 'AU/cm'
}
y_data = output_data[key_fmt.format(ii + offset)]
y_data = y_data * molecular_weight * ext_coeff
continuous_data[name] = XYData(name=name,
x_data=x_data,
x_metadata=x_metadata,
y_data=y_data,
y_metadata=y_metadata)
# Aggregate all component to build the total UV
total_conc += y_data
# create total concentration var
y_metadata = {
'name': 'Total_Sim',
'type': 'chromatogram',
'source': 'simulation',
'units': 'AU/cm'
}
continuous_data['Total_Sim'] = XYData(name='Total_Sim',
x_data=x_data,
x_metadata=x_metadata,
y_data=total_conc,
y_metadata=y_metadata)
# Read 3D column comp concentrations (across column and over time)---------
# Read in component concentrations inside the column liquid phase
key_fmt = 'solution_column'
column = output_data[key_fmt]
column = np.array(column)
for i, comp in enumerate(product.product_components):
# Collect component attributes:
comp_name = comp.name
molecular_weight = comp.molecular_weight[()]
ext_coeff = comp.extinction_coefficient[()]
name = comp_name + '_Column_Sim'
y_metadata = {
'name': name,
'type': 'column_liquid',
'source': 'simulation',
'units': 'AU/cm'
}
y_data = column[:, i + offset, :] * molecular_weight * ext_coeff
continuous_data[name] = XYData(name=name,
x_data=x_data,
x_metadata=x_metadata,
y_data=y_data,
y_metadata=y_metadata)
# Read in component concentrations inside the bead liquid phase
key_fmt = 'solution_particle'
data = np.array(output_data[key_fmt])
for i, comp in enumerate(product.product_components):
# Collect component attributes:
comp_name = comp.name
molecular_weight = comp.molecular_weight[()]
ext_coeff = comp.extinction_coefficient[()]
name = comp_name + '_Particle_Liq_Sim'
y_metadata = {
'name': name,
'type': 'particle_liquid',
'source': 'simulation',
'units': 'AU/cm'
}
y_data = data[:, :, :, 0, i + offset] * molecular_weight * ext_coeff
continuous_data[name] = XYData(name=name,
x_data=x_data,
x_metadata=x_metadata,
y_data=y_data,
y_metadata=y_metadata)
# Read in component concentrations inside the bead bound phase
key_fmt = 'solution_particle'
data = np.array(output_data[key_fmt])
for i, comp in enumerate(product.product_components):
# Collect component attributes:
comp_name = comp.name
molecular_weight = comp.molecular_weight[()]
ext_coeff = comp.extinction_coefficient[()]
name = comp_name + '_Particle_Bound_Sim'
y_metadata = {
'name': name,
'type': 'particle_bound',
'source': 'simulation',
'units': 'AU/cm'
}
y_data = data[:, :, :, 1, i + offset] * molecular_weight * ext_coeff
continuous_data[name] = XYData(name=name,
x_data=x_data,
x_metadata=x_metadata,
y_data=y_data,
y_metadata=y_metadata)
# Build tags for steps in simulation --------------------------------------
inlet_data = read_from_h5(output_fname, root='/input/model/inlet')
key_fmt = 'section_times'
section_times = inlet_data[key_fmt]
x_data = section_times[:-1]
x_metadata = {
'name': 'time',
'units': 's',
'source': 'simulation',
}
y_data = step_names
name = 'Section_Tags_Sim'
y_metadata = {
'name': name,
'type': 'section_tags',
'source': 'simulation',
'units': ''
}
continuous_data[name] = XYData(name=name,
x_data=x_data,
x_metadata=x_metadata,
y_data=y_data,
y_metadata=y_metadata)
return continuous_data
def test_plot_export_to_jpeg(self):
data = XYData(name="test", x_data=arange(20), y_data=arange(20))
filepath = "test.jpg"
with temp_fname(filepath):
data.mpl_show(filepath=filepath)
self.assertIn(filepath, listdir("."))
def test_create_fail_when_missing_name(self):
with self.assertRaises(ValueError):
XYData(x_data=arange(20), y_data=arange(20))
def test_create(self):
XYData(name="test", x_data=arange(20), y_data=arange(20))
def _build_fraction_data(self,
fraction_data,
time_of_origin=None,
target_experiment=None):
""" Convert fraction data from Excel fraction sheet into a fraction
data dictionary to describe ChromatographyResults.
Parameters
----------
fraction_data : dict
Data loaded from Excel.
time_of_origin : UnitScalar [OPTIONAL]
User specified custom time shift to apply to the data, if the
experimental output wasn't recorded starting at the desired start.
"""
if fraction_data is None:
return {}
if time_of_origin is None:
time_of_origin = UnitScalar(0., units="minute")
# Faction times at which product is sampled and analyzed:
frac_time = []
# Component concentration at each fraction time:
frac_comp_conc = defaultdict(list)
# Total concentration of product, corrected from extinction at each
# fraction time:
frac_prod_absorbances = []
product = self.product
for fraction in fraction_data:
prod_comp_assays = fraction.pop('product_component_assay_dict')
# FIXME: read units instead of guessing
total_concentration = self._get_unitted_value(
'fraction_product_concentration',
fraction['total_concentration'])
conc_units = total_concentration.units
# To compute the product concentrations in the fraction,
# we must first compute the concentration of each product component
# then multiply each by their respective extinction coefficient
# finally sum these values together
# FIXME: Fraction component concentrations shoud be calculated in
# SolutionWithProduct. This is probably unnecessary --
# Look into later.
namespace = {}
namespace.update(prod_comp_assays)
namespace["product_concentration"] = float(total_concentration)
prod_comp_conc = [
eval(expression, namespace)
for expression in product.product_component_concentration_exps
]
frac_component_concs = UnitArray(prod_comp_conc, units=conc_units)
# Total concentration, corrected by the components' extinction coef
ext_coefs = [
comp.extinction_coefficient
for comp in product.product_components
]
ext_coef_array = unitted_list_to_array(ext_coefs)
# This converts the component concentration to absorption
frac_component_absorb = frac_component_concs * ext_coef_array
tot_prod_absorbance = sum(frac_component_absorb)
frac_prod_absorbances.append(tot_prod_absorbance)
frac_time.append(fraction['time'])
for ii, comp_name in enumerate(product.product_component_names):
frac_comp_conc[comp_name].append(frac_component_absorb[ii])
# Apply the user defined origin shift:
# Warning: this leads to all fraction XYData sharing the same array!
frac_time = np.array(frac_time, dtype='float64') - time_of_origin[()]
frac_prod_absorbances = np.array(frac_prod_absorbances,
dtype='float64')
fraction_outputs = {}
for key, data in frac_comp_conc.items():
fraction_outputs[key] = XYData(
name=key,
x_data=frac_time,
# FIXME: read units instead of guessing
x_metadata={
"time_of_origin": time_of_origin,
"units": "min"
},
y_data=data,
# FIXME: read units instead of guessing
y_metadata={
"Description":
"Absorbances for product "
"components {}".format(key),
"units":
"AU/cm"
},
)
fraction_outputs[FRACTION_TOTAL_DATA_KEY] = XYData(
name=FRACTION_TOTAL_DATA_KEY,
x_data=frac_time,
# FIXME: read units instead of guessing
x_metadata={
"time_of_origin": time_of_origin,
"units": "min"
},
y_data=frac_prod_absorbances,
# FIXME: read units instead of guessing
y_metadata={
"Description": "Sum of absorbances per unit path "
"length for all product components.",
"units": "AU/cm"
},
)
shift_fraction_data_by_holdup_vol(fraction_outputs, target_experiment)
return fraction_outputs