def saxs_to_pif_properties(self,q_I,T_C):
#props = []
#for i in range(len(q)):
pq = pifobj.Property()
n_qpoints = q_I.shape[0]
### property: scattered intensity
pI = pifobj.Property()
pI.name = 'SAXS intensity'
pI.scalars = [pifobj.Scalar(q_I[i,1]) for i in range(n_qpoints)]
pI.units = 'counts'
pI.conditions = []
pI.conditions.append( pifobj.Value('SAXS scattering vector',
[pifobj.Scalar(q_I[i,0]) for i in range(n_qpoints)],
None,None,'1/Angstrom') )
pI.conditions.append(pifobj.Value('temperature',[pifobj.Scalar(T_C)],None,None,'degrees Celsius'))
return [pq,pI]
def q_I_property(self, q_I):
pI = pifobj.Property()
n_qpoints = q_I.shape[0]
pI.scalars = [pifobj.Scalar(q_I[i, 1]) for i in range(n_qpoints)]
pI.units = 'counts'
pI.conditions = []
pI.conditions.append(
pifobj.Value('scattering vector',
[pifobj.Scalar(q_I[i, 0]) for i in range(n_qpoints)],
None, None, None, '1/Angstrom'))
return pI
def time_feature_property(self, t_f, fname, funits=''):
pf = pifobj.Property()
pf.name = fname
npts = t_f.shape[0]
pf.scalars = [pifobj.Scalar(t_f[i, 1]) for i in range(npts)]
if funits:
pf.units = funits
pf.conditions = []
pf.conditions.append(
pifobj.Value('reaction time',
[pifobj.Scalar(t_f[i, 0]) for i in range(npts)], None,
None, None, 'seconds'))
return pf
def saxs_properties(q_I, temp_C, populations, params):
props = []
if q_I is not None:
# Process measured q_I into a property
pI = q_I_property(q_I)
if temp_C is not None:
pI.conditions.append(
pifobj.Value('temperature', [pifobj.Scalar(temp_C)], None,
None, None, 'degrees Celsius'))
props.append(pI)
if q_I is not None and params is not None and populations is not None:
if not bool(populations['unidentified']):
qcomp = np.arange(0., q_I[-1, 0], 0.001)
I_computed = saxs_math.compute_saxs(qcomp, populations, params)
pI_computed = q_I_property(np.array([qcomp, I_computed]).T,
propname='computed SAXS intensity')
props.append(pI_computed)
# add properties for the fit report
sxf = saxs_fit.SaxsFitter(q_I, populations)
report = sxf.fit_report(params)
rprops = fitreport_properties(report)
props.extend(rprops)
if q_I is not None:
# featurization of measured spectrum
prof = saxs_math.profile_spectrum(q_I)
prof_props = profile_properties(prof)
props.extend(prof_props)
if populations is not None:
# population-specific featurizations
det_profiles = saxs_math.detailed_profile(q_I, populations)
det_profile_props = profile_properties(det_profiles)
props.extend(det_profile_props)
# ML flags for this featurization
sxc = saxs_classify.SaxsClassifier()
ml_pops = sxc.classify(np.array(list(prof.values())).reshape(1, -1))
ml_pop_props = ml_population_properties(ml_pops)
props.extend(ml_pop_props)
if populations is not None:
fprops = ground_truth_population_properties(populations)
props.extend(fprops)
if params is not None:
pprops = param_properties(params)
props.extend(pprops)
return props
def q_I_property(q_I,
qunits='1/Angstrom',
Iunits='arb',
propname='SAXS intensity'):
pI = pifobj.Property()
n_qpoints = q_I.shape[0]
pI.scalars = [pifobj.Scalar(q_I[i, 1]) for i in range(n_qpoints)]
pI.units = Iunits
pI.conditions = []
pI.conditions.append(
pifobj.Value('scattering vector',
[pifobj.Scalar(q_I[i, 0]) for i in range(n_qpoints)],
None, None, None, qunits))
pI.name = propname
return pI
def run(self):
uid_pre = self.inputs['uid_prefix']
t_str = self.inputs['date_time']
t_utc = self.inputs['t_utc']
uid_full = 'tmp'
if uid_pre is not None:
uid_full = uid_pre
if t_utc is not None:
uid_full = uid_full + '_' + str(int(t_utc))
temp_C = self.inputs['temperature']
q_I = self.inputs['q_I']
ftrs = self.inputs['features']
# ChemicalSystem record construction begins here
csys = pifobj.ChemicalSystem()
csys.uid = uid_full
csys.properties = []
csys.tags = []
if uid_pre is not None:
csys.tags.append('reaction id: ' + uid_pre)
if t_str is not None:
csys.tags.append('date: ' + t_str)
if t_utc is not None:
csys.tags.append('utc: ' + str(int(t_utc)))
# TODO: include the scattering equation in this record somehow
if ftrs is not None:
if ftrs['bad_data']:
csys.tags.append('unidentified scattering or bad data')
if ftrs['diffraction_peaks']:
csys.tags.append('diffraction peaks')
if ftrs['form_factor_scattering']:
csys.tags.append('form factor scattering')
if not ftrs['diffraction_peaks'] and not ftrs['bad_data']:
csys.properties.append(
self.feature_property(None, 'nanoparticle mean radius',
'Angstrom'))
csys.properties.append(
self.feature_property(
None,
'fractional standard deviation of nanoparticle radius',
''))
csys.properties.append(
self.feature_property(
None, 'form factor scattering intensity prefactor',
'counts'))
if ftrs['precursor_scattering']:
csys.tags.append('precursor scattering')
if not ftrs['diffraction_peaks'] and not ftrs['bad_data']:
csys.properties.append(
self.feature_property(None,
'precursor effective radius',
'Angstrom'))
csys.properties.append(
self.feature_property(
None, 'precursor scattering intensity prefactor',
'counts'))
if q_I is not None:
# Process measured q_I into a property
pI = self.q_I_property(q_I)
if temp_C is not None:
pI.conditions.append(
pifobj.Value('temperature', [pifobj.Scalar(temp_C)], None,
None, None, 'degrees Celsius'))
pI.name = 'SAXS intensity'
csys.properties.append(pI)
if not ftrs['diffraction_peaks'] and not ftrs['bad_data']:
csys.properties.append(
self.feature_property(None, 'scattered intensity at q=0',
'counts'))
# Compute the saxs spectrum, package it
qI_computed = saxs_fit.compute_saxs(q_I[:, 0], ftrs)
pI_computed = self.q_I_property(
np.array([[q_I[i, 0], qI_computed[i]]
for i in range(len(qI_computed))]))
pI_computed.name = 'computed SAXS intensity'
csys.properties.append(pI_computed)
self.outputs['pif'] = csys