def _adjust_conditions(conds):
"Adjust conditions values to be within the numerical limit of the solver."
new_conds = OrderedDict()
for key, value in sorted(conds.items(), key=str):
if isinstance(key, v.Composition):
new_conds[key] = [max(val, MIN_SITE_FRACTION*1000) for val in unpack_condition(value)]
else:
new_conds[key] = unpack_condition(value)
return new_conds
def calculate(dbf, comps, phases, mode=None, output='GM', fake_points=False, broadcast=True, parameters=None, **kwargs):
"""
Sample the property surface of 'output' containing the specified
components and phases. Model parameters are taken from 'dbf' and any
state variables (T, P, etc.) can be specified as keyword arguments.
Parameters
----------
dbf : Database
Thermodynamic database containing the relevant parameters.
comps : str or sequence
Names of components to consider in the calculation.
phases : str or sequence
Names of phases to consider in the calculation.
mode : string, optional
See 'make_callable' docstring for details.
output : string, optional
Model attribute to sample.
fake_points : bool, optional (Default: False)
If True, the first few points of the output surface will be fictitious
points used to define an equilibrium hyperplane guaranteed to be above
all the other points. This is used for convex hull computations.
broadcast : bool, optional
If True, broadcast given state variable lists against each other to create a grid.
If False, assume state variables are given as equal-length lists.
points : ndarray or a dict of phase names to ndarray, optional
Columns of ndarrays must be internal degrees of freedom (site fractions), sorted.
If this is not specified, points will be generated automatically.
pdens : int, a dict of phase names to int, or a seq of both, optional
Number of points to sample per degree of freedom.
Default: 2000; Default when called from equilibrium(): 500
model : Model, a dict of phase names to Model, or a seq of both, optional
Model class to use for each phase.
sampler : callable, a dict of phase names to callable, or a seq of both, optional
Function to sample phase constitution space.
Must have same signature as 'pycalphad.core.utils.point_sample'
grid_points : bool, a dict of phase names to bool, or a seq of both, optional (Default: True)
Whether to add evenly spaced points between end-members.
The density of points is determined by 'pdens'
parameters : dict, optional
Maps SymPy Symbol to numbers, for overriding the values of parameters in the Database.
Returns
-------
Dataset of the sampled attribute as a function of state variables
Examples
--------
None yet.
"""
# Here we check for any keyword arguments that are special, i.e.,
# there may be keyword arguments that aren't state variables
pdens_dict = unpack_kwarg(kwargs.pop('pdens', 2000), default_arg=2000)
points_dict = unpack_kwarg(kwargs.pop('points', None), default_arg=None)
model_dict = unpack_kwarg(kwargs.pop('model', Model), default_arg=Model)
callable_dict = unpack_kwarg(kwargs.pop('callables', None), default_arg=None)
mass_dict = unpack_kwarg(kwargs.pop('massfuncs', None), default_arg=None)
sampler_dict = unpack_kwarg(kwargs.pop('sampler', None), default_arg=None)
fixedgrid_dict = unpack_kwarg(kwargs.pop('grid_points', True), default_arg=True)
parameters = parameters or dict()
if isinstance(parameters, dict):
parameters = OrderedDict(sorted(parameters.items(), key=str))
param_symbols = tuple(parameters.keys())
param_values = np.atleast_1d(np.array(list(parameters.values()), dtype=np.float))
if isinstance(phases, str):
phases = [phases]
if isinstance(comps, (str, v.Species)):
comps = [comps]
comps = sorted(unpack_components(dbf, comps))
if points_dict is None and broadcast is False:
raise ValueError('The \'points\' keyword argument must be specified if broadcast=False is also given.')
nonvacant_components = [x for x in sorted(comps) if x.number_of_atoms > 0]
# Convert keyword strings to proper state variable objects
# If we don't do this, sympy will get confused during substitution
statevar_dict = dict((v.StateVariable(key), unpack_condition(value)) for (key, value) in kwargs.items())
# XXX: CompiledModel assumes P, T are the only state variables
if statevar_dict.get(v.P, None) is None:
statevar_dict[v.P] = 101325
if statevar_dict.get(v.T, None) is None:
statevar_dict[v.T] = 300
# Sort after default state variable check to fix gh-116
statevar_dict = collections.OrderedDict(sorted(statevar_dict.items(), key=lambda x: str(x[0])))
str_statevar_dict = collections.OrderedDict((str(key), unpack_condition(value)) \
for (key, value) in statevar_dict.items())
all_phase_data = []
comp_sets = {}
largest_energy = 1e30
maximum_internal_dof = 0
# Consider only the active phases
active_phases = dict((name.upper(), dbf.phases[name.upper()]) \
for name in unpack_phases(phases))
for phase_name, phase_obj in sorted(active_phases.items()):
# Build the symbolic representation of the energy
mod = model_dict[phase_name]
# if this is an object type, we need to construct it
if isinstance(mod, type):
try:
model_dict[phase_name] = mod = mod(dbf, comps, phase_name, parameters=parameters)
except DofError:
# we can't build the specified phase because the
# specified components aren't found in every sublattice
# we'll just skip it
warnings.warn("""Suspending specified phase {} due to
some sublattices containing only unspecified components""".format(phase_name))
continue
if points_dict[phase_name] is None:
maximum_internal_dof = max(maximum_internal_dof, sum(len(x) for x in mod.constituents))
else:
maximum_internal_dof = max(maximum_internal_dof, np.asarray(points_dict[phase_name]).shape[-1])
for phase_name, phase_obj in sorted(active_phases.items()):
try:
mod = model_dict[phase_name]
except KeyError:
continue
# this is a phase model we couldn't construct for whatever reason; skip it
if isinstance(mod, type):
continue
# Construct an ordered list of the variables
variables, sublattice_dof = generate_dof(phase_obj, mod.components)
# Build the "fast" representation of that model
if callable_dict[phase_name] is None:
try:
out = getattr(mod, output)
except AttributeError:
raise AttributeError('Missing Model attribute {0} specified for {1}'
.format(output, mod.__class__))
# As a last resort, treat undefined symbols as zero
# But warn the user when we do this
# This is consistent with TC's behavior
undefs = list(out.atoms(Symbol) - out.atoms(v.StateVariable))
for undef in undefs:
out = out.xreplace({undef: float(0)})
warnings.warn('Setting undefined symbol {0} for phase {1} to zero'.format(undef, phase_name))
comp_sets[phase_name] = build_functions(out, list(statevar_dict.keys()) + variables,
include_obj=True, include_grad=False,
parameters=param_symbols)
else:
comp_sets[phase_name] = callable_dict[phase_name]
if mass_dict[phase_name] is None:
pure_elements = [spec for spec in nonvacant_components
if (len(spec.constituents.keys()) == 1 and
list(spec.constituents.keys())[0] == spec.name)
]
# TODO: In principle, we should also check for undefs in mod.moles()
mass_dict[phase_name] = [build_functions(mod.moles(el), list(statevar_dict.keys()) + variables,
include_obj=True, include_grad=False,
parameters=param_symbols)
for el in pure_elements]
phase_record = PhaseRecord_from_cython(comps, list(statevar_dict.keys()) + variables,
np.array(dbf.phases[phase_name].sublattices, dtype=np.float),
param_values, comp_sets[phase_name], None, None, mass_dict[phase_name], None)
points = points_dict[phase_name]
if points is None:
points = _sample_phase_constitution(phase_name, phase_obj.constituents, sublattice_dof, comps,
tuple(variables), sampler_dict[phase_name] or point_sample,
fixedgrid_dict[phase_name], pdens_dict[phase_name])
points = np.atleast_2d(points)
fp = fake_points and (phase_name == sorted(active_phases.keys())[0])
phase_ds = _compute_phase_values(nonvacant_components, str_statevar_dict,
points, phase_record, output,
maximum_internal_dof, broadcast=broadcast,
largest_energy=float(largest_energy), fake_points=fp)
all_phase_data.append(phase_ds)
# speedup for single-phase case (found by profiling)
if len(all_phase_data) > 1:
final_ds = concat(all_phase_data, dim='points')
final_ds['points'].values = np.arange(len(final_ds['points']))
final_ds.coords['points'].values = np.arange(len(final_ds['points']))
else:
final_ds = all_phase_data[0]
return final_ds
def calculate(dbf, comps, phases, mode=None, output='GM', fake_points=False, broadcast=True, parameters=None, **kwargs):
"""
Sample the property surface of 'output' containing the specified
components and phases. Model parameters are taken from 'dbf' and any
state variables (T, P, etc.) can be specified as keyword arguments.
Parameters
----------
dbf : Database
Thermodynamic database containing the relevant parameters.
comps : str or sequence
Names of components to consider in the calculation.
phases : str or sequence
Names of phases to consider in the calculation.
mode : string, optional
See 'make_callable' docstring for details.
output : string, optional
Model attribute to sample.
fake_points : bool, optional (Default: False)
If True, the first few points of the output surface will be fictitious
points used to define an equilibrium hyperplane guaranteed to be above
all the other points. This is used for convex hull computations.
broadcast : bool, optional
If True, broadcast given state variable lists against each other to create a grid.
If False, assume state variables are given as equal-length lists.
points : ndarray or a dict of phase names to ndarray, optional
Columns of ndarrays must be internal degrees of freedom (site fractions), sorted.
If this is not specified, points will be generated automatically.
pdens : int, a dict of phase names to int, or a seq of both, optional
Number of points to sample per degree of freedom.
Default: 2000; Default when called from equilibrium(): 500
model : Model, a dict of phase names to Model, or a seq of both, optional
Model class to use for each phase.
sampler : callable, a dict of phase names to callable, or a seq of both, optional
Function to sample phase constitution space.
Must have same signature as 'pycalphad.core.utils.point_sample'
grid_points : bool, a dict of phase names to bool, or a seq of both, optional (Default: True)
Whether to add evenly spaced points between end-members.
The density of points is determined by 'pdens'
parameters : dict, optional
Maps SymPy Symbol to numbers, for overriding the values of parameters in the Database.
Returns
-------
Dataset of the sampled attribute as a function of state variables
Examples
--------
None yet.
"""
# Here we check for any keyword arguments that are special, i.e.,
# there may be keyword arguments that aren't state variables
pdens_dict = unpack_kwarg(kwargs.pop('pdens', 2000), default_arg=2000)
points_dict = unpack_kwarg(kwargs.pop('points', None), default_arg=None)
callables = kwargs.pop('callables', {})
sampler_dict = unpack_kwarg(kwargs.pop('sampler', None), default_arg=None)
fixedgrid_dict = unpack_kwarg(kwargs.pop('grid_points', True), default_arg=True)
parameters = parameters or dict()
if isinstance(parameters, dict):
parameters = OrderedDict(sorted(parameters.items(), key=str))
if isinstance(phases, str):
phases = [phases]
if isinstance(comps, (str, v.Species)):
comps = [comps]
comps = sorted(unpack_components(dbf, comps))
if points_dict is None and broadcast is False:
raise ValueError('The \'points\' keyword argument must be specified if broadcast=False is also given.')
nonvacant_components = [x for x in sorted(comps) if x.number_of_atoms > 0]
all_phase_data = []
largest_energy = 1e10
# Consider only the active phases
list_of_possible_phases = filter_phases(dbf, comps)
active_phases = sorted(set(list_of_possible_phases).intersection(set(phases)))
active_phases = {name: dbf.phases[name] for name in active_phases}
if len(list_of_possible_phases) == 0:
raise ConditionError('There are no phases in the Database that can be active with components {0}'.format(comps))
if len(active_phases) == 0:
raise ConditionError('None of the passed phases ({0}) are active. List of possible phases: {1}.'
.format(phases, list_of_possible_phases))
models = instantiate_models(dbf, comps, list(active_phases.keys()), model=kwargs.pop('model', None), parameters=parameters)
if isinstance(output, (list, tuple, set)):
raise NotImplementedError('Only one property can be specified in calculate() at a time')
output = output if output is not None else 'GM'
# Implicitly add 'N' state variable as a string to keyword arguements if it's not passed
if kwargs.get('N') is None:
kwargs['N'] = 1
if np.any(np.array(kwargs['N']) != 1):
raise ConditionError('N!=1 is not yet supported, got N={}'.format(kwargs['N']))
# TODO: conditions dict of StateVariable instances should become part of the calculate API
statevar_strings = [sv for sv in kwargs.keys() if getattr(v, sv) is not None]
# If we don't do this, sympy will get confused during substitution
statevar_dict = dict((v.StateVariable(key), unpack_condition(value)) for key, value in kwargs.items() if key in statevar_strings)
# Sort after default state variable check to fix gh-116
statevar_dict = collections.OrderedDict(sorted(statevar_dict.items(), key=lambda x: str(x[0])))
phase_records = build_phase_records(dbf, comps, active_phases, statevar_dict,
models=models, parameters=parameters,
output=output, callables=callables,
verbose=kwargs.pop('verbose', False))
str_statevar_dict = collections.OrderedDict((str(key), unpack_condition(value)) \
for (key, value) in statevar_dict.items())
maximum_internal_dof = max(len(models[phase_name].site_fractions) for phase_name in active_phases)
for phase_name, phase_obj in sorted(active_phases.items()):
mod = models[phase_name]
phase_record = phase_records[phase_name]
points = points_dict[phase_name]
variables, sublattice_dof = generate_dof(phase_obj, mod.components)
if points is None:
points = _sample_phase_constitution(phase_name, phase_obj.constituents, sublattice_dof, comps,
tuple(variables), sampler_dict[phase_name] or point_sample,
fixedgrid_dict[phase_name], pdens_dict[phase_name])
points = np.atleast_2d(points)
fp = fake_points and (phase_name == sorted(active_phases.keys())[0])
phase_ds = _compute_phase_values(nonvacant_components, str_statevar_dict,
points, phase_record, output,
maximum_internal_dof, broadcast=broadcast,
largest_energy=float(largest_energy), fake_points=fp)
all_phase_data.append(phase_ds)
# speedup for single-phase case (found by profiling)
if len(all_phase_data) > 1:
final_ds = concat(all_phase_data, dim='points')
final_ds['points'].values = np.arange(len(final_ds['points']))
final_ds.coords['points'].values = np.arange(len(final_ds['points']))
else:
final_ds = all_phase_data[0]
return final_ds
def eqplot(eq, ax=None, x=None, y=None, z=None, tielines=True, **kwargs):
"""
Plot the result of an equilibrium calculation.
The type of plot is controlled by the degrees of freedom in the equilibrium calculation.
Parameters
----------
eq : xarray.Dataset
Result of equilibrium calculation.
ax : matplotlib.Axes
Default axes used if not specified.
x : StateVariable, optional
y : StateVariable, optional
z : StateVariable, optional
tielines : bool
If True, will plot tielines
kwargs : kwargs
Passed to `matplotlib.pyplot.scatter`.
Returns
-------
matplotlib AxesSubplot
"""
conds = OrderedDict([(_map_coord_to_variable(key), unpack_condition(np.asarray(value)))
for key, value in sorted(eq.coords.items(), key=str)
if (key == 'T') or (key == 'P') or (key.startswith('X_'))])
indep_comps = sorted([key for key, value in conds.items() if isinstance(key, v.Composition) and len(value) > 1], key=str)
indep_pots = [key for key, value in conds.items() if ((key == v.T) or (key == v.P)) and len(value) > 1]
# determine what the type of plot will be
if len(indep_comps) == 1 and len(indep_pots) == 1:
projection = None
elif len(indep_comps) == 2 and len(indep_pots) == 0:
projection = 'triangular'
else:
raise ValueError('The eqplot projection is not defined and cannot be autodetected. There are {} independent compositions and {} indepedent potentials.'.format(len(indep_comps), len(indep_pots)))
if z is not None:
raise NotImplementedError('3D plotting is not yet implemented')
if ax is None:
fig = plt.figure()
ax = fig.gca(projection=projection)
ax = plt.gca(projection=projection) if ax is None else ax
# Handle cases for different plot types
if projection is None:
x = indep_comps[0] if x is None else x
y = indep_pots[0] if y is None else y
# plot settings
ax.set_xlim([np.min(conds[x]) - 1e-2, np.max(conds[x]) + 1e-2])
ax.set_ylim([np.min(conds[y]), np.max(conds[y])])
elif projection == 'triangular':
x = indep_comps[0] if x is None else x
y = indep_comps[1] if y is None else y
# plot settings
ax.yaxis.label.set_rotation(60)
# Here we adjust the x coordinate of the ylabel.
# We make it reasonably comparable to the position of the xlabel from the xaxis
# As the figure size gets very large, the label approaches ~0.55 on the yaxis
# 0.55*cos(60 deg)=0.275, so that is the xcoord we are approaching.
ax.yaxis.label.set_va('baseline')
fig_x_size = ax.figure.get_size_inches()[0]
y_label_offset = 1 / fig_x_size
ax.yaxis.set_label_coords(x=(0.275 - y_label_offset), y=0.5)
# get the active phases and support loading netcdf files from disk
phases = map(str, sorted(set(np.array(eq.Phase.values.ravel(), dtype='U')) - {''}, key=str))
comps = map(str, sorted(np.array(eq.coords['component'].values, dtype='U'), key=str))
eq['component'] = np.array(eq['component'], dtype='U')
eq['Phase'].values = np.array(eq['Phase'].values, dtype='U')
# Select all two- and three-phase regions
three_phase_idx = np.nonzero(np.sum(eq.Phase.values != '', axis=-1, dtype=np.int) == 3)
two_phase_idx = np.nonzero(np.sum(eq.Phase.values != '', axis=-1, dtype=np.int) == 2)
legend_handles, colorlist = phase_legend(phases)
# For both two and three phase, cast the tuple of indices to an array and flatten
# If we found two phase regions:
if two_phase_idx[0].size > 0:
found_two_phase = eq.Phase.values[two_phase_idx][..., :2]
# get tieline endpoint compositions
two_phase_x = eq.X.sel(component=x.species.name).values[two_phase_idx][..., :2]
# handle special case for potential
if isinstance(y, v.Composition):
two_phase_y = eq.X.sel(component=y.species.name).values[two_phase_idx][..., :2]
else:
# it's a StateVariable. This must be True
two_phase_y = np.take(eq[str(y)].values, two_phase_idx[list(str(i) for i in conds.keys()).index(str(y))])
# because the above gave us a shape of (n,) instead of (n,2) we are going to create it ourselves
two_phase_y = np.array([two_phase_y, two_phase_y]).swapaxes(0, 1)
# plot two phase points
two_phase_plotcolors = np.array(list(map(lambda x: [colorlist[x[0]], colorlist[x[1]]], found_two_phase)), dtype='U') # from pycalphad
ax.scatter(two_phase_x[..., 0], two_phase_y[..., 0], s=3, c=two_phase_plotcolors[:,0], edgecolors='None', zorder=2, **kwargs)
ax.scatter(two_phase_x[..., 1], two_phase_y[..., 1], s=3, c=two_phase_plotcolors[:,1], edgecolors='None', zorder=2, **kwargs)
if tielines:
# construct and plot tielines
two_phase_tielines = np.array([np.concatenate((two_phase_x[..., 0][..., np.newaxis], two_phase_y[..., 0][..., np.newaxis]), axis=-1),
np.concatenate((two_phase_x[..., 1][..., np.newaxis], two_phase_y[..., 1][..., np.newaxis]), axis=-1)])
two_phase_tielines = np.rollaxis(two_phase_tielines, 1)
lc = mc.LineCollection(two_phase_tielines, zorder=1, colors=[0,1,0,1], linewidths=[0.5, 0.5])
ax.add_collection(lc)
# If we found three phase regions:
if three_phase_idx[0].size > 0:
found_three_phase = eq.Phase.values[three_phase_idx][..., :3]
# get tieline endpoints
three_phase_x = eq.X.sel(component=x.species.name).values[three_phase_idx][..., :3]
three_phase_y = eq.X.sel(component=y.species.name).values[three_phase_idx][..., :3]
# three phase tielines, these are tie triangles and we always plot them
three_phase_tielines = np.array([np.concatenate((three_phase_x[..., 0][..., np.newaxis], three_phase_y[..., 0][..., np.newaxis]), axis=-1),
np.concatenate((three_phase_x[..., 1][..., np.newaxis], three_phase_y[..., 1][..., np.newaxis]), axis=-1),
np.concatenate((three_phase_x[..., 2][..., np.newaxis], three_phase_y[..., 2][..., np.newaxis]), axis=-1)])
three_phase_tielines = np.rollaxis(three_phase_tielines,1)
three_lc = mc.LineCollection(three_phase_tielines, zorder=1, colors=[1,0,0,1], linewidths=[0.5, 0.5])
# plot three phase points and tielines
three_phase_plotcolors = np.array(list(map(lambda x: [colorlist[x[0]], colorlist[x[1]], colorlist[x[2]]], found_three_phase)), dtype='U') # from pycalphad
ax.scatter(three_phase_x[..., 0], three_phase_y[..., 0], s=3, c=three_phase_plotcolors[:, 0], edgecolors='None', zorder=2, **kwargs)
ax.scatter(three_phase_x[..., 1], three_phase_y[..., 1], s=3, c=three_phase_plotcolors[:, 1], edgecolors='None', zorder=2, **kwargs)
ax.scatter(three_phase_x[..., 2], three_phase_y[..., 2], s=3, c=three_phase_plotcolors[:, 2], edgecolors='None', zorder=2, **kwargs)
ax.add_collection(three_lc)
# position the phase legend and configure plot
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
ax.legend(handles=legend_handles, loc='center left', bbox_to_anchor=(1, 0.5))
ax.tick_params(axis='both', which='major', labelsize=14)
ax.grid(True)
plot_title = '-'.join([component.title() for component in sorted(comps) if component != 'VA'])
ax.set_title(plot_title, fontsize=20)
ax.set_xlabel(_axis_label(x), labelpad=15, fontsize=20)
ax.set_ylabel(_axis_label(y), fontsize=20)
return ax
def calculate(dbf, comps, phases, mode=None, output='GM', fake_points=False, broadcast=True, tmpman=None, **kwargs):
"""
Sample the property surface of 'output' containing the specified
components and phases. Model parameters are taken from 'dbf' and any
state variables (T, P, etc.) can be specified as keyword arguments.
Parameters
----------
dbf : Database
Thermodynamic database containing the relevant parameters.
comps : str or sequence
Names of components to consider in the calculation.
phases : str or sequence
Names of phases to consider in the calculation.
mode : string, optional
See 'make_callable' docstring for details.
output : string, optional
Model attribute to sample.
fake_points : bool, optional (Default: False)
If True, the first few points of the output surface will be fictitious
points used to define an equilibrium hyperplane guaranteed to be above
all the other points. This is used for convex hull computations.
broadcast : bool, optional
If True, broadcast given state variable lists against each other to create a grid.
If False, assume state variables are given as equal-length lists.
tmpman : TempfileManager, optional
Context manager for temporary file creation during the calculation.
points : ndarray or a dict of phase names to ndarray, optional
Columns of ndarrays must be internal degrees of freedom (site fractions), sorted.
If this is not specified, points will be generated automatically.
pdens : int, a dict of phase names to int, or a seq of both, optional
Number of points to sample per degree of freedom.
model : Model, a dict of phase names to Model, or a seq of both, optional
Model class to use for each phase.
sampler : callable, a dict of phase names to callable, or a seq of both, optional
Function to sample phase constitution space.
Must have same signature as 'pycalphad.core.utils.point_sample'
grid_points : bool, a dict of phase names to bool, or a seq of both, optional (Default: True)
Whether to add evenly spaced points between end-members.
The density of points is determined by 'pdens'
Returns
-------
Dataset of the sampled attribute as a function of state variables
Examples
--------
None yet.
"""
# Here we check for any keyword arguments that are special, i.e.,
# there may be keyword arguments that aren't state variables
pdens_dict = unpack_kwarg(kwargs.pop('pdens', 2000), default_arg=2000)
points_dict = unpack_kwarg(kwargs.pop('points', None), default_arg=None)
model_dict = unpack_kwarg(kwargs.pop('model', Model), default_arg=Model)
callable_dict = unpack_kwarg(kwargs.pop('callables', None), default_arg=None)
sampler_dict = unpack_kwarg(kwargs.pop('sampler', None), default_arg=None)
fixedgrid_dict = unpack_kwarg(kwargs.pop('grid_points', True), default_arg=True)
if isinstance(phases, str):
phases = [phases]
if isinstance(comps, str):
comps = [comps]
if points_dict is None and broadcast is False:
raise ValueError('The \'points\' keyword argument must be specified if broadcast=False is also given.')
components = [x for x in sorted(comps) if not x.startswith('VA')]
# Convert keyword strings to proper state variable objects
# If we don't do this, sympy will get confused during substitution
statevar_dict = collections.OrderedDict((v.StateVariable(key), unpack_condition(value)) \
for (key, value) in sorted(kwargs.items()))
str_statevar_dict = collections.OrderedDict((str(key), unpack_condition(value)) \
for (key, value) in statevar_dict.items())
all_phase_data = []
comp_sets = {}
largest_energy = -np.inf
maximum_internal_dof = 0
# Consider only the active phases
active_phases = dict((name.upper(), dbf.phases[name.upper()]) \
for name in unpack_phases(phases))
for phase_name, phase_obj in sorted(active_phases.items()):
# Build the symbolic representation of the energy
mod = model_dict[phase_name]
# if this is an object type, we need to construct it
if isinstance(mod, type):
try:
model_dict[phase_name] = mod = mod(dbf, comps, phase_name)
except DofError:
# we can't build the specified phase because the
# specified components aren't found in every sublattice
# we'll just skip it
logger.warning("""Suspending specified phase %s due to
some sublattices containing only unspecified components""",
phase_name)
continue
if points_dict[phase_name] is None:
try:
out = getattr(mod, output)
maximum_internal_dof = max(maximum_internal_dof, len(out.atoms(v.SiteFraction)))
except AttributeError:
raise AttributeError('Missing Model attribute {0} specified for {1}'
.format(output, mod.__class__))
else:
maximum_internal_dof = max(maximum_internal_dof, np.asarray(points_dict[phase_name]).shape[-1])
for phase_name, phase_obj in sorted(active_phases.items()):
try:
mod = model_dict[phase_name]
except KeyError:
continue
# Construct an ordered list of the variables
variables, sublattice_dof = generate_dof(phase_obj, mod.components)
# Build the "fast" representation of that model
if callable_dict[phase_name] is None:
out = getattr(mod, output)
# As a last resort, treat undefined symbols as zero
# But warn the user when we do this
# This is consistent with TC's behavior
undefs = list(out.atoms(Symbol) - out.atoms(v.StateVariable))
for undef in undefs:
out = out.xreplace({undef: float(0)})
logger.warning('Setting undefined symbol %s for phase %s to zero',
undef, phase_name)
comp_sets[phase_name] = build_functions(out, list(statevar_dict.keys()) + variables, tmpman=tmpman,
include_obj=True, include_grad=False, include_hess=False)
else:
comp_sets[phase_name] = callable_dict[phase_name]
points = points_dict[phase_name]
if points is None:
# Eliminate pure vacancy endmembers from the calculation
vacancy_indices = list()
for idx, sublattice in enumerate(phase_obj.constituents):
active_in_subl = sorted(set(phase_obj.constituents[idx]).intersection(comps))
if 'VA' in active_in_subl and 'VA' in sorted(comps):
vacancy_indices.append(active_in_subl.index('VA'))
if len(vacancy_indices) != len(phase_obj.constituents):
vacancy_indices = None
logger.debug('vacancy_indices: %s', vacancy_indices)
# Add all endmembers to guarantee their presence
points = endmember_matrix(sublattice_dof,
vacancy_indices=vacancy_indices)
if fixedgrid_dict[phase_name] is True:
# Sample along the edges of the endmembers
# These constitution space edges are often the equilibrium points!
em_pairs = list(itertools.combinations(points, 2))
for first_em, second_em in em_pairs:
extra_points = first_em * np.linspace(0, 1, pdens_dict[phase_name])[np.newaxis].T + \
second_em * np.linspace(0, 1, pdens_dict[phase_name])[::-1][np.newaxis].T
points = np.concatenate((points, extra_points))
# Sample composition space for more points
if sum(sublattice_dof) > len(sublattice_dof):
sampler = sampler_dict[phase_name]
if sampler is None:
sampler = point_sample
points = np.concatenate((points,
sampler(sublattice_dof,
pdof=pdens_dict[phase_name])
))
# If there are nontrivial sublattices with vacancies in them,
# generate a set of points where their fraction is zero and renormalize
for idx, sublattice in enumerate(phase_obj.constituents):
if 'VA' in set(sublattice) and len(sublattice) > 1:
var_idx = variables.index(v.SiteFraction(phase_name, idx, 'VA'))
addtl_pts = np.copy(points)
# set vacancy fraction to log-spaced between 1e-10 and 1e-6
addtl_pts[:, var_idx] = np.power(10.0, -10.0*(1.0 - addtl_pts[:, var_idx]))
# renormalize site fractions
cur_idx = 0
for ctx in sublattice_dof:
end_idx = cur_idx + ctx
addtl_pts[:, cur_idx:end_idx] /= \
addtl_pts[:, cur_idx:end_idx].sum(axis=1)[:, None]
cur_idx = end_idx
# add to points matrix
points = np.concatenate((points, addtl_pts), axis=0)
# Filter out nan's that may have slipped in if we sampled too high a vacancy concentration
# Issues with this appear to be platform-dependent
points = points[~np.isnan(points).any(axis=-1)]
# Ensure that points has the correct dimensions and dtype
points = np.atleast_2d(np.asarray(points, dtype=np.float))
phase_ds = _compute_phase_values(phase_obj, components, variables, str_statevar_dict,
points, comp_sets[phase_name], output,
maximum_internal_dof, broadcast=broadcast)
# largest_energy is really only relevant if fake_points is set
if fake_points:
largest_energy = max(phase_ds[output].max(), largest_energy)
all_phase_data.append(phase_ds)
if fake_points:
if output != 'GM':
raise ValueError('fake_points=True should only be used with output=\'GM\'')
phase_ds = _generate_fake_points(components, statevar_dict, largest_energy, output,
maximum_internal_dof, broadcast)
final_ds = concat(itertools.chain([phase_ds], all_phase_data),
dim='points')
else:
# speedup for single-phase case (found by profiling)
if len(all_phase_data) > 1:
final_ds = concat(all_phase_data, dim='points')
else:
final_ds = all_phase_data[0]
if (not fake_points) and (len(all_phase_data) == 1):
pass
else:
# Reset the points dimension to use a single global index
final_ds['points'] = np.arange(len(final_ds.points))
return final_ds
def equilibrium(dbf, comps, phases, conditions, **kwargs):
"""
Calculate the equilibrium state of a system containing the specified
components and phases, under the specified conditions.
Model parameters are taken from 'dbf'.
Parameters
----------
dbf : Database
Thermodynamic database containing the relevant parameters.
comps : list
Names of components to consider in the calculation.
phases : list or dict
Names of phases to consider in the calculation.
conditions : dict or (list of dict)
StateVariables and their corresponding value.
verbose : bool, optional (Default: True)
Show progress of calculations.
grid_opts : dict, optional
Keyword arguments to pass to the initial grid routine.
Returns
-------
Structured equilibrium calculation.
Examples
--------
None yet.
"""
active_phases = unpack_phases(phases) or sorted(dbf.phases.keys())
comps = sorted(comps)
indep_vars = ['T', 'P']
grid_opts = kwargs.pop('grid_opts', dict())
verbose = kwargs.pop('verbose', True)
phase_records = dict()
callable_dict = kwargs.pop('callables', dict())
grad_callable_dict = kwargs.pop('grad_callables', dict())
hess_callable_dict = kwargs.pop('hess_callables', dict())
points_dict = dict()
maximum_internal_dof = 0
conds = OrderedDict((key, unpack_condition(value)) for key, value in sorted(conditions.items(), key=str))
str_conds = OrderedDict((str(key), value) for key, value in conds.items())
indep_vals = list([float(x) for x in np.atleast_1d(val)]
for key, val in str_conds.items() if key in indep_vars)
components = [x for x in sorted(comps) if not x.startswith('VA')]
# Construct models for each phase; prioritize user models
models = unpack_kwarg(kwargs.pop('model', Model), default_arg=Model)
if verbose:
print('Components:', ' '.join(comps))
print('Phases:', end=' ')
for name in active_phases:
mod = models[name]
if isinstance(mod, type):
models[name] = mod = mod(dbf, comps, name)
variables = sorted(mod.energy.atoms(v.StateVariable).union({key for key in conditions.keys() if key in [v.T, v.P]}), key=str)
site_fracs = sorted(mod.energy.atoms(v.SiteFraction), key=str)
maximum_internal_dof = max(maximum_internal_dof, len(site_fracs))
# Extra factor '1e-100...' is to work around an annoying broadcasting bug for zero gradient entries
#models[name].models['_broadcaster'] = 1e-100 * Mul(*variables) ** 3
out = models[name].energy
undefs = list(out.atoms(Symbol) - out.atoms(v.StateVariable))
for undef in undefs:
out = out.xreplace({undef: float(0)})
callable_dict[name], grad_callable_dict[name], hess_callable_dict[name] = \
build_functions(out, [v.P, v.T] + site_fracs)
# Adjust gradient by the approximate chemical potentials
hyperplane = Add(*[v.MU(i)*mole_fraction(dbf.phases[name], comps, i)
for i in comps if i != 'VA'])
plane_obj, plane_grad, plane_hess = build_functions(hyperplane, [v.MU(i) for i in comps if i != 'VA']+site_fracs)
phase_records[name.upper()] = PhaseRecord(variables=variables,
grad=grad_callable_dict[name],
hess=hess_callable_dict[name],
plane_grad=plane_grad,
plane_hess=plane_hess)
if verbose:
print(name, end=' ')
if verbose:
print('[done]', end='\n')
# 'calculate' accepts conditions through its keyword arguments
grid_opts.update({key: value for key, value in str_conds.items() if key in indep_vars})
if 'pdens' not in grid_opts:
grid_opts['pdens'] = 100
coord_dict = str_conds.copy()
coord_dict['vertex'] = np.arange(len(components))
grid_shape = np.meshgrid(*coord_dict.values(),
indexing='ij', sparse=False)[0].shape
coord_dict['component'] = components
if verbose:
print('Computing initial grid', end=' ')
grid = calculate(dbf, comps, active_phases, output='GM',
model=models, callables=callable_dict, fake_points=True, **grid_opts)
if verbose:
print('[{0} points, {1}]'.format(len(grid.points), sizeof_fmt(grid.nbytes)), end='\n')
properties = xray.Dataset({'NP': (list(str_conds.keys()) + ['vertex'],
np.empty(grid_shape)),
'GM': (list(str_conds.keys()),
np.empty(grid_shape[:-1])),
'MU': (list(str_conds.keys()) + ['component'],
np.empty(grid_shape)),
'points': (list(str_conds.keys()) + ['vertex'],
np.empty(grid_shape, dtype=np.int))
},
coords=coord_dict,
attrs={'iterations': 1},
)
# Store the potentials from the previous iteration
current_potentials = properties.MU.copy()
for iteration in range(MAX_ITERATIONS):
if verbose:
print('Computing convex hull [iteration {}]'.format(properties.attrs['iterations']))
# lower_convex_hull will modify properties
lower_convex_hull(grid, properties)
progress = np.abs(current_potentials - properties.MU).values
converged = (progress < MIN_PROGRESS).all(axis=-1)
if verbose:
print('progress', progress.max(), '[{} conditions updated]'.format(np.sum(~converged)))
if progress.max() < MIN_PROGRESS:
if verbose:
print('Convergence achieved')
break
current_potentials[...] = properties.MU.values
if verbose:
print('Refining convex hull')
# Insert extra dimensions for non-T,P conditions so GM broadcasts correctly
energy_broadcast_shape = grid.GM.values.shape[:len(indep_vals)] + \
(1,) * (len(str_conds) - len(indep_vals)) + (grid.GM.values.shape[-1],)
driving_forces = np.einsum('...i,...i',
properties.MU.values[..., np.newaxis, :].astype(np.float),
grid.X.values[np.index_exp[...] +
(np.newaxis,) * (len(str_conds) - len(indep_vals)) +
np.index_exp[:, :]].astype(np.float)) - \
grid.GM.values.view().reshape(energy_broadcast_shape)
for name in active_phases:
dof = len(models[name].energy.atoms(v.SiteFraction))
current_phase_indices = (grid.Phase.values == name).reshape(energy_broadcast_shape[:-1] + (-1,))
# Broadcast to capture all conditions
current_phase_indices = np.broadcast_arrays(current_phase_indices,
np.empty(driving_forces.shape))[0]
# This reshape is safe as long as phases have the same number of points at all indep. conditions
current_phase_driving_forces = driving_forces[current_phase_indices].reshape(
current_phase_indices.shape[:-1] + (-1,))
# Note: This works as long as all points are in the same phase order for all T, P
current_site_fractions = grid.Y.values[..., current_phase_indices[(0,) * len(str_conds)], :]
if np.sum(current_site_fractions[(0,) * len(indep_vals)][..., :dof]) == dof:
# All site fractions are 1, aka zero internal degrees of freedom
# Impossible to refine these points, so skip this phase
points_dict[name] = current_site_fractions[(0,) * len(indep_vals)][..., :dof]
continue
# Find the N points with largest driving force for a given set of conditions
# Remember that driving force has a sign, so we want the "most positive" values
# N is the number of components, in this context
# N points define a 'best simplex' for every set of conditions
# We also need to restrict ourselves to one phase at a time
trial_indices = np.argpartition(current_phase_driving_forces,
-len(components), axis=-1)[..., -len(components):]
trial_indices = trial_indices.ravel()
statevar_indices = np.unravel_index(np.arange(np.multiply.reduce(properties.GM.values.shape + (len(components),))),
properties.GM.values.shape + (len(components),))[:len(indep_vals)]
points = current_site_fractions[np.index_exp[statevar_indices + (trial_indices,)]]
points.shape = properties.points.shape[:-1] + (-1, maximum_internal_dof)
# The Y arrays have been padded, so we should slice off the padding
points = points[..., :dof]
#print('Starting points shape: ', points.shape)
#print(points)
if len(points) == 0:
if name in points_dict:
del points_dict[name]
# No nearly stable points: skip this phase
continue
num_vars = len(phase_records[name].variables)
plane_grad = phase_records[name].plane_grad
plane_hess = phase_records[name].plane_hess
statevar_grid = np.meshgrid(*itertools.chain(indep_vals), sparse=True, indexing='ij')
# TODO: A more sophisticated treatment of constraints
num_constraints = len(dbf.phases[name].sublattices)
constraint_jac = np.zeros((num_constraints, num_vars-len(indep_vars)))
# Independent variables are always fixed (in this limited implementation)
#for idx in range(len(indep_vals)):
# constraint_jac[idx, idx] = 1
# This is for site fraction balance constraints
var_idx = 0#len(indep_vals)
for idx in range(len(dbf.phases[name].sublattices)):
active_in_subl = set(dbf.phases[name].constituents[idx]).intersection(comps)
constraint_jac[idx,
var_idx:var_idx + len(active_in_subl)] = 1
var_idx += len(active_in_subl)
newton_iteration = 0
while newton_iteration < MAX_NEWTON_ITERATIONS:
flattened_points = points.reshape(points.shape[:len(indep_vals)] + (-1, points.shape[-1]))
grad_args = itertools.chain([i[..., None] for i in statevar_grid],
[flattened_points[..., i] for i in range(flattened_points.shape[-1])])
grad = np.array(phase_records[name].grad(*grad_args), dtype=np.float)
# Remove derivatives wrt T,P
grad = grad[..., len(indep_vars):]
grad.shape = points.shape
grad[np.isnan(grad).any(axis=-1)] = 0 # This is necessary for gradients on the edge of space
hess_args = itertools.chain([i[..., None] for i in statevar_grid],
[flattened_points[..., i] for i in range(flattened_points.shape[-1])])
hess = np.array(phase_records[name].hess(*hess_args), dtype=np.float)
# Remove derivatives wrt T,P
hess = hess[..., len(indep_vars):, len(indep_vars):]
hess.shape = points.shape + (hess.shape[-1],)
hess[np.isnan(hess).any(axis=(-2, -1))] = np.eye(hess.shape[-1])
plane_args = itertools.chain([properties.MU.values[..., i][..., None] for i in range(properties.MU.shape[-1])],
[points[..., i] for i in range(points.shape[-1])])
cast_grad = np.array(plane_grad(*plane_args), dtype=np.float)
# Remove derivatives wrt chemical potentials
cast_grad = cast_grad[..., properties.MU.shape[-1]:]
grad = grad - cast_grad
plane_args = itertools.chain([properties.MU.values[..., i][..., None] for i in range(properties.MU.shape[-1])],
[points[..., i] for i in range(points.shape[-1])])
cast_hess = np.array(plane_hess(*plane_args), dtype=np.float)
# Remove derivatives wrt chemical potentials
cast_hess = cast_hess[..., properties.MU.shape[-1]:, properties.MU.shape[-1]:]
cast_hess = -cast_hess + hess
hess = cast_hess.astype(np.float, copy=False)
try:
e_matrix = np.linalg.inv(hess)
except np.linalg.LinAlgError:
print(hess)
raise
current = calculate(dbf, comps, name, output='GM',
model=models, callables=callable_dict,
fake_points=False,
points=points.reshape(points.shape[:len(indep_vals)] + (-1, points.shape[-1])),
**grid_opts)
current_plane = np.multiply(current.X.values.reshape(points.shape[:-1] + (len(components),)),
properties.MU.values[..., np.newaxis, :]).sum(axis=-1)
current_df = current.GM.values.reshape(points.shape[:-1]) - current_plane
#print('Inv hess check: ', np.isnan(e_matrix).any())
#print('grad check: ', np.isnan(grad).any())
dy_unconstrained = -np.einsum('...ij,...j->...i', e_matrix, grad)
#print('dy_unconstrained check: ', np.isnan(dy_unconstrained).any())
proj_matrix = np.dot(e_matrix, constraint_jac.T)
inv_matrix = np.rollaxis(np.dot(constraint_jac, proj_matrix), 0, -1)
inv_term = np.linalg.inv(inv_matrix)
#print('inv_term check: ', np.isnan(inv_term).any())
first_term = np.einsum('...ij,...jk->...ik', proj_matrix, inv_term)
#print('first_term check: ', np.isnan(first_term).any())
# Normally a term for the residual here
# We only choose starting points which obey the constraints, so r = 0
cons_summation = np.einsum('...i,...ji->...j', dy_unconstrained, constraint_jac)
#print('cons_summation check: ', np.isnan(cons_summation).any())
cons_correction = np.einsum('...ij,...j->...i', first_term, cons_summation)
#print('cons_correction check: ', np.isnan(cons_correction).any())
dy_constrained = dy_unconstrained - cons_correction
#print('dy_constrained check: ', np.isnan(dy_constrained).any())
# TODO: Support for adaptive changing independent variable steps
new_direction = dy_constrained
#print('new_direction', new_direction)
#print('points', points)
# Backtracking line search
if np.isnan(new_direction).any():
print('new_direction', new_direction)
#print('Convergence angle:', -(grad*new_direction).sum(axis=-1) / (np.linalg.norm(grad, axis=-1) * np.linalg.norm(new_direction, axis=-1)))
new_points = points + INITIAL_STEP_SIZE * new_direction
alpha = np.full(new_points.shape[:-1], INITIAL_STEP_SIZE, dtype=np.float)
alpha[np.all(np.linalg.norm(new_direction, axis=-1) < MIN_DIRECTION_NORM, axis=-1)] = 0
negative_points = np.any(new_points < 0., axis=-1)
while np.any(negative_points):
alpha[negative_points] *= 0.5
new_points = points + alpha[..., np.newaxis] * new_direction
negative_points = np.any(new_points < 0., axis=-1)
# Backtracking line search
# alpha now contains maximum possible values that keep us inside the space
# but we don't just want to take the biggest step; we want the biggest step which reduces energy
new_points = new_points.reshape(new_points.shape[:len(indep_vals)] + (-1, new_points.shape[-1]))
candidates = calculate(dbf, comps, name, output='GM',
model=models, callables=callable_dict,
fake_points=False, points=new_points, **grid_opts)
candidate_plane = np.multiply(candidates.X.values.reshape(points.shape[:-1] + (len(components),)),
properties.MU.values[..., np.newaxis, :]).sum(axis=-1)
energy_diff = (candidates.GM.values.reshape(new_direction.shape[:-1]) - candidate_plane) - current_df
new_points.shape = new_direction.shape
bad_steps = energy_diff > alpha * 1e-4 * (new_direction * grad).sum(axis=-1)
backtracking_iterations = 0
while np.any(bad_steps):
alpha[bad_steps] *= 0.5
new_points = points + alpha[..., np.newaxis] * new_direction
#print('new_points', new_points)
#print('bad_steps', bad_steps)
new_points = new_points.reshape(new_points.shape[:len(indep_vals)] + (-1, new_points.shape[-1]))
candidates = calculate(dbf, comps, name, output='GM',
model=models, callables=callable_dict,
fake_points=False, points=new_points, **grid_opts)
candidate_plane = np.multiply(candidates.X.values.reshape(points.shape[:-1] + (len(components),)),
properties.MU.values[..., np.newaxis, :]).sum(axis=-1)
energy_diff = (candidates.GM.values.reshape(new_direction.shape[:-1]) - candidate_plane) - current_df
#print('energy_diff', energy_diff)
new_points.shape = new_direction.shape
bad_steps = energy_diff > alpha * 1e-4 * (new_direction * grad).sum(axis=-1)
backtracking_iterations += 1
if backtracking_iterations > MAX_BACKTRACKING:
break
biggest_step = np.max(np.linalg.norm(new_points - points, axis=-1))
if biggest_step < 1e-2:
if verbose:
print('N-R convergence on mini-iteration', newton_iteration, '[{}]'.format(name))
points = new_points
break
if verbose:
#print('Biggest step:', biggest_step)
#print('points', points)
#print('grad of points', grad)
#print('new_direction', new_direction)
#print('alpha', alpha)
#print('new_points', new_points)
pass
points = new_points
newton_iteration += 1
new_points = points.reshape(points.shape[:len(indep_vals)] + (-1, points.shape[-1]))
new_points = np.concatenate((current_site_fractions[..., :dof], new_points), axis=-2)
points_dict[name] = new_points
if verbose:
print('Rebuilding grid', end=' ')
grid = calculate(dbf, comps, active_phases, output='GM',
model=models, callables=callable_dict,
fake_points=True, points=points_dict, **grid_opts)
if verbose:
print('[{0} points, {1}]'.format(len(grid.points), sizeof_fmt(grid.nbytes)), end='\n')
properties.attrs['iterations'] += 1
# One last call to ensure 'properties' and 'grid' are consistent with one another
lower_convex_hull(grid, properties)
ravelled_X_view = grid['X'].values.view().reshape(-1, grid['X'].values.shape[-1])
ravelled_Y_view = grid['Y'].values.view().reshape(-1, grid['Y'].values.shape[-1])
ravelled_Phase_view = grid['Phase'].values.view().reshape(-1)
# Copy final point values from the grid and drop the index array
# For some reason direct construction doesn't work. We have to create empty and then assign.
properties['X'] = xray.DataArray(np.empty_like(ravelled_X_view[properties['points'].values]),
dims=properties['points'].dims + ('component',))
properties['X'].values[...] = ravelled_X_view[properties['points'].values]
properties['Y'] = xray.DataArray(np.empty_like(ravelled_Y_view[properties['points'].values]),
dims=properties['points'].dims + ('internal_dof',))
properties['Y'].values[...] = ravelled_Y_view[properties['points'].values]
# TODO: What about invariant reactions? We should perform a final driving force calculation here.
# We can handle that in the same post-processing step where we identify single-phase regions.
properties['Phase'] = xray.DataArray(np.empty_like(ravelled_Phase_view[properties['points'].values]),
dims=properties['points'].dims)
properties['Phase'].values[...] = ravelled_Phase_view[properties['points'].values]
del properties['points']
return properties
def calculate(dbf,
comps,
phases,
mode=None,
output='GM',
fake_points=False,
broadcast=True,
parameters=None,
**kwargs):
"""
Sample the property surface of 'output' containing the specified
components and phases. Model parameters are taken from 'dbf' and any
state variables (T, P, etc.) can be specified as keyword arguments.
Parameters
----------
dbf : Database
Thermodynamic database containing the relevant parameters.
comps : str or sequence
Names of components to consider in the calculation.
phases : str or sequence
Names of phases to consider in the calculation.
mode : string, optional
See 'make_callable' docstring for details.
output : string, optional
Model attribute to sample.
fake_points : bool, optional (Default: False)
If True, the first few points of the output surface will be fictitious
points used to define an equilibrium hyperplane guaranteed to be above
all the other points. This is used for convex hull computations.
broadcast : bool, optional
If True, broadcast given state variable lists against each other to create a grid.
If False, assume state variables are given as equal-length lists.
points : ndarray or a dict of phase names to ndarray, optional
Columns of ndarrays must be internal degrees of freedom (site fractions), sorted.
If this is not specified, points will be generated automatically.
pdens : int, a dict of phase names to int, or a seq of both, optional
Number of points to sample per degree of freedom.
Default: 2000; Default when called from equilibrium(): 500
model : Model, a dict of phase names to Model, or a seq of both, optional
Model class to use for each phase.
sampler : callable, a dict of phase names to callable, or a seq of both, optional
Function to sample phase constitution space.
Must have same signature as 'pycalphad.core.utils.point_sample'
grid_points : bool, a dict of phase names to bool, or a seq of both, optional (Default: True)
Whether to add evenly spaced points between end-members.
The density of points is determined by 'pdens'
parameters : dict, optional
Maps SymPy Symbol to numbers, for overriding the values of parameters in the Database.
Returns
-------
Dataset of the sampled attribute as a function of state variables
Examples
--------
None yet.
"""
# Here we check for any keyword arguments that are special, i.e.,
# there may be keyword arguments that aren't state variables
pdens_dict = unpack_kwarg(kwargs.pop('pdens', 2000), default_arg=2000)
points_dict = unpack_kwarg(kwargs.pop('points', None), default_arg=None)
callables = kwargs.pop('callables', {})
sampler_dict = unpack_kwarg(kwargs.pop('sampler', None), default_arg=None)
fixedgrid_dict = unpack_kwarg(kwargs.pop('grid_points', True),
default_arg=True)
parameters = parameters or dict()
if isinstance(parameters, dict):
parameters = OrderedDict(sorted(parameters.items(), key=str))
if isinstance(phases, str):
phases = [phases]
if isinstance(comps, (str, v.Species)):
comps = [comps]
comps = sorted(unpack_components(dbf, comps))
if points_dict is None and broadcast is False:
raise ValueError(
'The \'points\' keyword argument must be specified if broadcast=False is also given.'
)
nonvacant_components = [x for x in sorted(comps) if x.number_of_atoms > 0]
all_phase_data = []
largest_energy = 1e10
# Consider only the active phases
list_of_possible_phases = filter_phases(dbf, comps)
active_phases = sorted(
set(list_of_possible_phases).intersection(set(phases)))
active_phases = {name: dbf.phases[name] for name in active_phases}
if len(list_of_possible_phases) == 0:
raise ConditionError(
'There are no phases in the Database that can be active with components {0}'
.format(comps))
if len(active_phases) == 0:
raise ConditionError(
'None of the passed phases ({0}) are active. List of possible phases: {1}.'
.format(phases, list_of_possible_phases))
models = instantiate_models(dbf,
comps,
list(active_phases.keys()),
model=kwargs.pop('model', None),
parameters=parameters)
if isinstance(output, (list, tuple, set)):
raise NotImplementedError(
'Only one property can be specified in calculate() at a time')
output = output if output is not None else 'GM'
# Implicitly add 'N' state variable as a string to keyword arguements if it's not passed
if kwargs.get('N') is None:
kwargs['N'] = 1
if np.any(np.array(kwargs['N']) != 1):
raise ConditionError('N!=1 is not yet supported, got N={}'.format(
kwargs['N']))
# TODO: conditions dict of StateVariable instances should become part of the calculate API
statevar_strings = [
sv for sv in kwargs.keys() if getattr(v, sv) is not None
]
# If we don't do this, sympy will get confused during substitution
statevar_dict = dict((v.StateVariable(key), unpack_condition(value))
for key, value in kwargs.items()
if key in statevar_strings)
# Sort after default state variable check to fix gh-116
statevar_dict = collections.OrderedDict(
sorted(statevar_dict.items(), key=lambda x: str(x[0])))
phase_records = build_phase_records(dbf,
comps,
active_phases,
statevar_dict,
models=models,
parameters=parameters,
output=output,
callables=callables,
verbose=kwargs.pop('verbose', False))
str_statevar_dict = collections.OrderedDict((str(key), unpack_condition(value)) \
for (key, value) in statevar_dict.items())
maximum_internal_dof = max(
len(models[phase_name].site_fractions) for phase_name in active_phases)
for phase_name, phase_obj in sorted(active_phases.items()):
mod = models[phase_name]
phase_record = phase_records[phase_name]
points = points_dict[phase_name]
variables, sublattice_dof = generate_dof(phase_obj, mod.components)
if points is None:
points = _sample_phase_constitution(
phase_name, phase_obj.constituents, sublattice_dof, comps,
tuple(variables), sampler_dict[phase_name] or point_sample,
fixedgrid_dict[phase_name], pdens_dict[phase_name])
points = np.atleast_2d(points)
fp = fake_points and (phase_name == sorted(active_phases.keys())[0])
phase_ds = _compute_phase_values(nonvacant_components,
str_statevar_dict,
points,
phase_record,
output,
maximum_internal_dof,
broadcast=broadcast,
largest_energy=float(largest_energy),
fake_points=fp)
all_phase_data.append(phase_ds)
# speedup for single-phase case (found by profiling)
if len(all_phase_data) > 1:
final_ds = concat(all_phase_data, dim='points')
final_ds['points'].values = np.arange(len(final_ds['points']))
final_ds.coords['points'].values = np.arange(len(final_ds['points']))
else:
final_ds = all_phase_data[0]
return final_ds
def equilibrium(dbf, comps, phases, conditions, **kwargs):
"""
Calculate the equilibrium state of a system containing the specified
components and phases, under the specified conditions.
Model parameters are taken from 'dbf'.
Parameters
----------
dbf : Database
Thermodynamic database containing the relevant parameters.
comps : list
Names of components to consider in the calculation.
phases : list or dict
Names of phases to consider in the calculation.
conditions : dict or (list of dict)
StateVariables and their corresponding value.
verbose : bool, optional (Default: True)
Show progress of calculations.
grid_opts : dict, optional
Keyword arguments to pass to the initial grid routine.
Returns
-------
Structured equilibrium calculation.
Examples
--------
None yet.
"""
active_phases = unpack_phases(phases) or sorted(dbf.phases.keys())
comps = sorted(comps)
indep_vars = ['T', 'P']
grid_opts = kwargs.pop('grid_opts', dict())
verbose = kwargs.pop('verbose', True)
phase_records = dict()
callable_dict = kwargs.pop('callables', dict())
grad_callable_dict = kwargs.pop('grad_callables', dict())
points_dict = dict()
maximum_internal_dof = 0
# Construct models for each phase; prioritize user models
models = unpack_kwarg(kwargs.pop('model', Model), default_arg=Model)
if verbose:
print('Components:', ' '.join(comps))
print('Phases:', end=' ')
for name in active_phases:
mod = models[name]
if isinstance(mod, type):
models[name] = mod = mod(dbf, comps, name)
variables = sorted(mod.energy.atoms(v.StateVariable).union({key for key in conditions.keys() if key in [v.T, v.P]}), key=str)
site_fracs = sorted(mod.energy.atoms(v.SiteFraction), key=str)
maximum_internal_dof = max(maximum_internal_dof, len(site_fracs))
# Extra factor '1e-100...' is to work around an annoying broadcasting bug for zero gradient entries
models[name].models['_broadcaster'] = 1e-100 * Mul(*variables) ** 3
out = models[name].energy
if name not in callable_dict:
undefs = list(out.atoms(Symbol) - out.atoms(v.StateVariable))
for undef in undefs:
out = out.xreplace({undef: float(0)})
# callable_dict takes variables in a different order due to calculate() pecularities
callable_dict[name] = make_callable(out,
sorted((key for key in conditions.keys() if key in [v.T, v.P]),
key=str) + site_fracs)
if name not in grad_callable_dict:
grad_func = make_callable(Matrix([out]).jacobian(variables), variables)
else:
grad_func = grad_callable_dict[name]
# Adjust gradient by the approximate chemical potentials
plane_vars = sorted(models[name].energy.atoms(v.SiteFraction), key=str)
hyperplane = Add(*[v.MU(i)*mole_fraction(dbf.phases[name], comps, i)
for i in comps if i != 'VA'])
# Workaround an annoying bug with zero gradient entries
# This forces numerically zero entries to broadcast correctly
hyperplane += 1e-100 * Mul(*([v.MU(i) for i in comps if i != 'VA'] + plane_vars + [v.T, v.P])) ** 3
plane_grad = make_callable(Matrix([hyperplane]).jacobian(variables),
[v.MU(i) for i in comps if i != 'VA'] + plane_vars + [v.T, v.P])
plane_hess = make_callable(hessian(hyperplane, variables),
[v.MU(i) for i in comps if i != 'VA'] + plane_vars + [v.T, v.P])
phase_records[name.upper()] = PhaseRecord(variables=variables,
grad=grad_func,
plane_grad=plane_grad,
plane_hess=plane_hess)
if verbose:
print(name, end=' ')
if verbose:
print('[done]', end='\n')
conds = OrderedDict((key, unpack_condition(value)) for key, value in sorted(conditions.items(), key=str))
str_conds = OrderedDict((str(key), value) for key, value in conds.items())
indep_vals = list([float(x) for x in np.atleast_1d(val)]
for key, val in str_conds.items() if key in indep_vars)
components = [x for x in sorted(comps) if not x.startswith('VA')]
# 'calculate' accepts conditions through its keyword arguments
grid_opts.update({key: value for key, value in str_conds.items() if key in indep_vars})
if 'pdens' not in grid_opts:
grid_opts['pdens'] = 10
coord_dict = str_conds.copy()
coord_dict['vertex'] = np.arange(len(components))
grid_shape = np.meshgrid(*coord_dict.values(),
indexing='ij', sparse=False)[0].shape
coord_dict['component'] = components
if verbose:
print('Computing initial grid', end=' ')
grid = calculate(dbf, comps, active_phases, output='GM',
model=models, callables=callable_dict, fake_points=True, **grid_opts)
if verbose:
print('[{0} points, {1}]'.format(len(grid.points), sizeof_fmt(grid.nbytes)), end='\n')
properties = xray.Dataset({'NP': (list(str_conds.keys()) + ['vertex'],
np.empty(grid_shape)),
'GM': (list(str_conds.keys()),
np.empty(grid_shape[:-1])),
'MU': (list(str_conds.keys()) + ['component'],
np.empty(grid_shape)),
'points': (list(str_conds.keys()) + ['vertex'],
np.empty(grid_shape, dtype=np.int))
},
coords=coord_dict,
attrs={'iterations': 1},
)
# Store the potentials from the previous iteration
current_potentials = properties.MU.copy()
for iteration in range(MAX_ITERATIONS):
if verbose:
print('Computing convex hull [iteration {}]'.format(properties.attrs['iterations']))
# lower_convex_hull will modify properties
lower_convex_hull(grid, properties)
progress = np.abs(current_potentials - properties.MU).max().values
if verbose:
print('progress', progress)
if progress < MIN_PROGRESS:
if verbose:
print('Convergence achieved')
break
current_potentials[...] = properties.MU.values
if verbose:
print('Refining convex hull')
# Insert extra dimensions for non-T,P conditions so GM broadcasts correctly
energy_broadcast_shape = grid.GM.values.shape[:len(indep_vals)] + \
(1,) * (len(str_conds) - len(indep_vals)) + (grid.GM.values.shape[-1],)
driving_forces = np.einsum('...i,...i',
properties.MU.values[..., np.newaxis, :],
grid.X.values[np.index_exp[...] +
(np.newaxis,) * (len(str_conds) - len(indep_vals)) +
np.index_exp[:, :]]) - \
grid.GM.values.view().reshape(energy_broadcast_shape)
for name in active_phases:
dof = len(models[name].energy.atoms(v.SiteFraction))
current_phase_indices = (grid.Phase.values == name).reshape(energy_broadcast_shape[:-1] + (-1,))
# Broadcast to capture all conditions
current_phase_indices = np.broadcast_arrays(current_phase_indices,
np.empty(driving_forces.shape))[0]
# This reshape is safe as long as phases have the same number of points at all indep. conditions
current_phase_driving_forces = driving_forces[current_phase_indices].reshape(
current_phase_indices.shape[:-1] + (-1,))
# Note: This works as long as all points are in the same phase order for all T, P
current_site_fractions = grid.Y.values[..., current_phase_indices[(0,) * len(str_conds)], :]
if np.sum(current_site_fractions[(0,) * len(indep_vals)][..., :dof]) == dof:
# All site fractions are 1, aka zero internal degrees of freedom
# Impossible to refine these points, so skip this phase
points_dict[name] = current_site_fractions[(0,) * len(indep_vals)][..., :dof]
continue
# Find the N points with largest driving force for a given set of conditions
# Remember that driving force has a sign, so we want the "most positive" values
# N is the number of components, in this context
# N points define a 'best simplex' for every set of conditions
# We also need to restrict ourselves to one phase at a time
trial_indices = np.argpartition(current_phase_driving_forces,
-len(components), axis=-1)[..., -len(components):]
trial_indices = trial_indices.ravel()
statevar_indices = np.unravel_index(np.arange(np.multiply.reduce(properties.GM.values.shape + (len(components),))),
properties.GM.values.shape + (len(components),))[:len(indep_vals)]
points = current_site_fractions[np.index_exp[statevar_indices + (trial_indices,)]]
points.shape = properties.points.shape[:-1] + (-1, maximum_internal_dof)
# The Y arrays have been padded, so we should slice off the padding
points = points[..., :dof]
# Workaround for derivative issues at endmembers
points[points == 0.] = MIN_SITE_FRACTION
if len(points) == 0:
if name in points_dict:
del points_dict[name]
# No nearly stable points: skip this phase
continue
num_vars = len(phase_records[name].variables)
plane_grad = phase_records[name].plane_grad
plane_hess = phase_records[name].plane_hess
statevar_grid = np.meshgrid(*itertools.chain(indep_vals), sparse=True, indexing='xy')
# TODO: A more sophisticated treatment of constraints
num_constraints = len(indep_vals) + len(dbf.phases[name].sublattices)
constraint_jac = np.zeros((num_constraints, num_vars))
# Independent variables are always fixed (in this limited implementation)
for idx in range(len(indep_vals)):
constraint_jac[idx, idx] = 1
# This is for site fraction balance constraints
var_idx = len(indep_vals)
for idx in range(len(dbf.phases[name].sublattices)):
active_in_subl = set(dbf.phases[name].constituents[idx]).intersection(comps)
constraint_jac[len(indep_vals) + idx,
var_idx:var_idx + len(active_in_subl)] = 1
var_idx += len(active_in_subl)
grad = phase_records[name].grad(*itertools.chain(statevar_grid, points.T))
if grad.dtype == 'object':
# Workaround a bug in zero gradient entries
grad_zeros = np.zeros(points.T.shape[1:], dtype=np.float)
for i in np.arange(grad.shape[0]):
if isinstance(grad[i], int):
grad[i] = grad_zeros
grad = np.array(grad.tolist(), dtype=np.float)
bcasts = np.broadcast_arrays(*itertools.chain(properties.MU.values.T, points.T))
cast_grad = -plane_grad(*itertools.chain(bcasts, [0], [0]))
cast_grad = cast_grad.T + grad.T
grad = cast_grad
grad.shape = grad.shape[:-1] # Remove extraneous dimension
# This Hessian is an approximation updated using the BFGS method
# See Nocedal and Wright, ch.3, p. 198
# Initialize as identity matrix
hess = broadcast_to(np.eye(num_vars), grad.shape + (grad.shape[-1],)).copy()
newton_iteration = 0
while newton_iteration < MAX_NEWTON_ITERATIONS:
e_matrix = np.linalg.inv(hess)
dy_unconstrained = -np.einsum('...ij,...j->...i', e_matrix, grad)
proj_matrix = np.dot(e_matrix, constraint_jac.T)
inv_matrix = np.rollaxis(np.dot(constraint_jac, proj_matrix), 0, -1)
inv_term = np.linalg.inv(inv_matrix)
first_term = np.einsum('...ij,...jk->...ik', proj_matrix, inv_term)
# Normally a term for the residual here
# We only choose starting points which obey the constraints, so r = 0
cons_summation = np.einsum('...i,...ji->...j', dy_unconstrained, constraint_jac)
cons_correction = np.einsum('...ij,...j->...i', first_term, cons_summation)
dy_constrained = dy_unconstrained - cons_correction
# TODO: Support for adaptive changing independent variable steps
new_direction = dy_constrained[..., len(indep_vals):]
# Backtracking line search
new_points = points + INITIAL_STEP_SIZE * new_direction
alpha = np.full(new_points.shape[:-1], INITIAL_STEP_SIZE, dtype=np.float)
negative_points = np.any(new_points < 0., axis=-1)
while np.any(negative_points):
alpha[negative_points] *= 0.1
new_points = points + alpha[..., np.newaxis] * new_direction
negative_points = np.any(new_points < 0., axis=-1)
# If we made "near" zero progress on any points, don't update the Hessian until
# we've rebuilt the convex hull
# Nocedal and Wright recommend against skipping Hessian updates
# They recommend using a damped update approach, pp. 538-539 of their book
# TODO: Check the projected gradient norm, not the step length
if np.any(np.max(np.abs(alpha[..., np.newaxis] * new_direction), axis=-1) < MIN_STEP_LENGTH):
break
# Workaround for derivative issues at endmembers
new_points[new_points == 0.] = 1e-16
# BFGS update to Hessian
new_grad = phase_records[name].grad(*itertools.chain(statevar_grid, new_points.T))
if new_grad.dtype == 'object':
# Workaround a bug in zero gradient entries
grad_zeros = np.zeros(new_points.T.shape[1:], dtype=np.float)
for i in np.arange(new_grad.shape[0]):
if isinstance(new_grad[i], int):
new_grad[i] = grad_zeros
new_grad = np.array(new_grad.tolist(), dtype=np.float)
bcasts = np.broadcast_arrays(*itertools.chain(properties.MU.values.T, new_points.T))
cast_grad = -plane_grad(*itertools.chain(bcasts, [0], [0]))
cast_grad = cast_grad.T + new_grad.T
new_grad = cast_grad
new_grad.shape = new_grad.shape[:-1] # Remove extraneous dimension
# Notation used here consistent with Nocedal and Wright
s_k = np.empty(points.shape[:-1] + (points.shape[-1] + len(indep_vals),))
# Zero out independent variable changes for now
s_k[..., :len(indep_vals)] = 0
s_k[..., len(indep_vals):] = new_points - points
y_k = new_grad - grad
s_s_term = np.einsum('...j,...k->...jk', s_k, s_k)
s_b_s_term = np.einsum('...i,...ij,...j', s_k, hess, s_k)
y_y_y_s_term = np.einsum('...j,...k->...jk', y_k, y_k) / \
np.einsum('...i,...i', y_k, s_k)[..., np.newaxis, np.newaxis]
update = np.einsum('...ij,...jk,...kl->...il', hess, s_s_term, hess) / \
s_b_s_term[..., np.newaxis, np.newaxis] + y_y_y_s_term
hess = hess - update
cast_hess = -plane_hess(*itertools.chain(bcasts, [0], [0])).T + hess
hess = -cast_hess #TODO: Why does this fix things?
# TODO: Verify that the chosen step lengths reduce the energy
points = new_points
grad = new_grad
newton_iteration += 1
new_points = new_points.reshape(new_points.shape[:len(indep_vals)] + (-1, new_points.shape[-1]))
new_points = np.concatenate((current_site_fractions[..., :dof], new_points), axis=-2)
points_dict[name] = new_points
if verbose:
print('Rebuilding grid', end=' ')
grid = calculate(dbf, comps, active_phases, output='GM',
model=models, callables=callable_dict,
fake_points=True, points=points_dict, **grid_opts)
if verbose:
print('[{0} points, {1}]'.format(len(grid.points), sizeof_fmt(grid.nbytes)), end='\n')
properties.attrs['iterations'] += 1
# One last call to ensure 'properties' and 'grid' are consistent with one another
lower_convex_hull(grid, properties)
ravelled_X_view = grid['X'].values.view().reshape(-1, grid['X'].values.shape[-1])
ravelled_Y_view = grid['Y'].values.view().reshape(-1, grid['Y'].values.shape[-1])
ravelled_Phase_view = grid['Phase'].values.view().reshape(-1)
# Copy final point values from the grid and drop the index array
# For some reason direct construction doesn't work. We have to create empty and then assign.
properties['X'] = xray.DataArray(np.empty_like(ravelled_X_view[properties['points'].values]),
dims=properties['points'].dims + ('component',))
properties['X'].values[...] = ravelled_X_view[properties['points'].values]
properties['Y'] = xray.DataArray(np.empty_like(ravelled_Y_view[properties['points'].values]),
dims=properties['points'].dims + ('internal_dof',))
properties['Y'].values[...] = ravelled_Y_view[properties['points'].values]
# TODO: What about invariant reactions? We should perform a final driving force calculation here.
# We can handle that in the same post-processing step where we identify single-phase regions.
properties['Phase'] = xray.DataArray(np.empty_like(ravelled_Phase_view[properties['points'].values]),
dims=properties['points'].dims)
properties['Phase'].values[...] = ravelled_Phase_view[properties['points'].values]
del properties['points']
return properties
def eqplot(eq, ax=None, x=None, y=None, z=None, **kwargs):
"""
Plot the result of an equilibrium calculation.
Parameters
----------
eq : xarray.Dataset
Result of equilibrium calculation.
ax : matplotlib.Axes
Default axes used if not specified.
x : StateVariable, optional
y : StateVariable, optional
z : StateVariable, optional
kwargs : kwargs
Passed to `matplotlib.pyplot.scatter`.
Returns
-------
matplotlib AxesSubplot
"""
ax = plt.gca() if ax is None else ax
conds = OrderedDict([(_map_coord_to_variable(key), unpack_condition(np.asarray(value)))
for key, value in sorted(eq.coords.items(), key=str)
if (key == 'T') or (key == 'P') or (key.startswith('X_'))])
indep_comp = [key for key, value in conds.items() if isinstance(key, v.Composition) and len(value) > 1]
indep_pot = [key for key, value in conds.items() if ((key == v.T) or (key == v.P)) and len(value) > 1]
if (len(indep_comp) != 1) or (len(indep_pot) != 1):
raise ValueError('Plot currently requires exactly one composition and one potential coordinate')
indep_comp = indep_comp[0]
indep_pot = indep_pot[0]
x = indep_comp if x is None else x
y = indep_pot if y is None else y
if z is not None:
raise NotImplementedError('3D plotting is not yet implemented')
# TODO: Temporary workaround to fix string encoding issue when loading netcdf files from disk
phases = map(str, sorted(set(np.array(eq.Phase.values.ravel(), dtype='U')) - {''}, key=str))
comps = map(str, sorted(np.array(eq.coords['component'].values, dtype='U'), key=str))
eq['component'] = np.array(eq['component'], dtype='U')
eq['Phase'].values = np.array(eq['Phase'].values, dtype='U')
# Select all two-phase regions
two_phase_indices = np.nonzero(np.sum(eq.Phase.values != '', axis=-1, dtype=np.int) == 2)
found_phases = eq.Phase.values[two_phase_indices][..., :2]
colorlist = {}
# colors from Junwei Huang, March 21 2013
# exclude green and red because of their special meaning on the diagram
colorvalues = ["0000FF", "FFFF00", "FF00FF", "00FFFF", "000000",
"800000", "008000", "000080", "808000", "800080", "008080",
"808080", "C00000", "00C000", "0000C0", "C0C000", "C000C0",
"00C0C0", "C0C0C0", "400000", "004000", "000040", "404000",
"400040", "004040", "404040", "200000", "002000", "000020",
"202000", "200020", "002020", "202020", "600000", "006000",
"000060", "606000", "600060", "006060", "606060", "A00000",
"00A000", "0000A0", "A0A000", "A000A0", "00A0A0", "A0A0A0",
"E00000", "00E000", "0000E0", "E0E000", "E000E0", "00E0E0",
"E0E0E0"]
phasecount = 0
legend_handles = []
for phase in phases:
phase = phase.upper()
colorlist[phase] = "#"+colorvalues[np.mod(phasecount, len(colorvalues))]
legend_handles.append(mpatches.Patch(color=colorlist[phase], label=phase))
phasecount += 1
# position the phase legend
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
ax.legend(handles=legend_handles, loc='center left', bbox_to_anchor=(1, 0.5))
ax.tick_params(axis='both', which='major', labelsize=14)
ax.grid(True)
plotcolors = np.array(list(map(lambda x: [colorlist[x[0]], colorlist[x[1]]], found_phases)), dtype='U')
if isinstance(x, v.Composition):
compositions = eq.X.sel(component=x.species).values[two_phase_indices][..., :2]
else:
raise NotImplementedError('Plotting {} is not yet implemented'.format(x))
# Have to do some extra work to get all potential values for the given tie lines
temps = np.take(eq[str(y)].values, two_phase_indices[list(str(i) for i in conds.keys()).index(str(y))])
if ax is None:
ax = plt.gca()
# Draw zero phase-fraction lines
ax.scatter(compositions[..., 0], temps, s=3, c=plotcolors[..., 0], edgecolors='None', zorder=2, **kwargs)
ax.scatter(compositions[..., 1], temps, s=3, c=plotcolors[..., 1], edgecolors='None', zorder=2, **kwargs)
# Draw tie-lines
tielines = np.array([np.concatenate((compositions[..., 0][..., np.newaxis], temps[..., np.newaxis]), axis=-1),
np.concatenate((compositions[..., 1][..., np.newaxis], temps[..., np.newaxis]), axis=-1)])
tielines = np.rollaxis(tielines, 1)
lc = mc.LineCollection(tielines, zorder=1, colors=[0, 1, 0, 1], linewidths=[0.5, 0.5])
ax.add_collection(lc)
plot_title = '-'.join([x.title() for x in sorted(comps) if x != 'VA'])
ax.set_title(plot_title, fontsize=20)
ax.set_xlim([np.min(conds[indep_comp])-1e-2, np.max(conds[indep_comp])+1e-2])
ax.set_ylim([np.min(conds[indep_pot]), np.max(conds[indep_pot])])
if isinstance(x, v.Composition):
ax.set_xlabel('X({})'.format(indep_comp.species), labelpad=15, fontsize=20)
else:
ax.set_xlabel(indep_comp, labelpad=15, fontsize=20)
ax.set_ylabel(_plot_labels[indep_pot], fontsize=20)
return ax
def calculate(dbf,
comps,
phases,
mode=None,
output='GM',
fake_points=False,
broadcast=True,
parameters=None,
to_xarray=True,
phase_records=None,
**kwargs):
"""
Sample the property surface of 'output' containing the specified
components and phases. Model parameters are taken from 'dbf' and any
state variables (T, P, etc.) can be specified as keyword arguments.
Parameters
----------
dbf : Database
Thermodynamic database containing the relevant parameters.
comps : str or sequence
Names of components to consider in the calculation.
phases : str or sequence
Names of phases to consider in the calculation.
mode : string, optional
See 'make_callable' docstring for details.
output : string, optional
Model attribute to sample.
fake_points : bool, optional (Default: False)
If True, the first few points of the output surface will be fictitious
points used to define an equilibrium hyperplane guaranteed to be above
all the other points. This is used for convex hull computations.
broadcast : bool, optional
If True, broadcast given state variable lists against each other to create a grid.
If False, assume state variables are given as equal-length lists.
points : ndarray or a dict of phase names to ndarray, optional
Columns of ndarrays must be internal degrees of freedom (site fractions), sorted.
If this is not specified, points will be generated automatically.
pdens : int, a dict of phase names to int, or a seq of both, optional
Number of points to sample per degree of freedom.
Default: 2000; Default when called from equilibrium(): 500
model : Model, a dict of phase names to Model, or a seq of both, optional
Model class to use for each phase.
sampler : callable, a dict of phase names to callable, or a seq of both, optional
Function to sample phase constitution space.
Must have same signature as 'pycalphad.core.utils.point_sample'
grid_points : bool, a dict of phase names to bool, or a seq of both, optional (Default: True)
Whether to add evenly spaced points between end-members.
The density of points is determined by 'pdens'
parameters : dict, optional
Maps SymEngine Symbol to numbers, for overriding the values of parameters in the Database.
phase_records : Optional[Mapping[str, PhaseRecord]]
Mapping of phase names to PhaseRecord objects. Must include all active phases.
The `model` argument must be a mapping of phase names to instances of Model
objects. Callers must take care that the PhaseRecord objects were created with
the same `output` as passed to `calculate`.
Returns
-------
Dataset of the sampled attribute as a function of state variables
Examples
--------
None yet.
"""
# Here we check for any keyword arguments that are special, i.e.,
# there may be keyword arguments that aren't state variables
pdens_dict = unpack_kwarg(kwargs.pop('pdens', 2000), default_arg=2000)
points_dict = unpack_kwarg(kwargs.pop('points', None), default_arg=None)
callables = kwargs.pop('callables', {})
sampler_dict = unpack_kwarg(kwargs.pop('sampler', None), default_arg=None)
fixedgrid_dict = unpack_kwarg(kwargs.pop('grid_points', True),
default_arg=True)
model = kwargs.pop('model', None)
parameters = parameters or dict()
if isinstance(parameters, dict):
parameters = OrderedDict(sorted(parameters.items(), key=str))
if isinstance(phases, str):
phases = [phases]
if isinstance(comps, (str, v.Species)):
comps = [comps]
comps = sorted(unpack_components(dbf, comps))
if points_dict is None and broadcast is False:
raise ValueError(
'The \'points\' keyword argument must be specified if broadcast=False is also given.'
)
nonvacant_components = [x for x in sorted(comps) if x.number_of_atoms > 0]
nonvacant_elements = get_pure_elements(dbf, comps)
all_phase_data = []
largest_energy = 1e10
# Consider only the active phases
list_of_possible_phases = filter_phases(dbf, comps)
if len(list_of_possible_phases) == 0:
raise ConditionError(
'There are no phases in the Database that can be active with components {0}'
.format(comps))
active_phases = filter_phases(dbf, comps, phases)
if len(active_phases) == 0:
raise ConditionError(
'None of the passed phases ({0}) are active. List of possible phases: {1}.'
.format(phases, list_of_possible_phases))
if isinstance(output, (list, tuple, set)):
raise NotImplementedError(
'Only one property can be specified in calculate() at a time')
output = output if output is not None else 'GM'
# Implicitly add 'N' state variable as a string to keyword arguements if it's not passed
if kwargs.get('N') is None:
kwargs['N'] = 1
if np.any(np.array(kwargs['N']) != 1):
raise ConditionError('N!=1 is not yet supported, got N={}'.format(
kwargs['N']))
# TODO: conditions dict of StateVariable instances should become part of the calculate API
statevar_strings = [
sv for sv in kwargs.keys() if getattr(v, sv) is not None
]
# If we don't do this, sympy will get confused during substitution
statevar_dict = dict((v.StateVariable(key), unpack_condition(value))
for key, value in kwargs.items()
if key in statevar_strings)
# Sort after default state variable check to fix gh-116
statevar_dict = OrderedDict(
sorted(statevar_dict.items(), key=lambda x: str(x[0])))
str_statevar_dict = OrderedDict((str(key), unpack_condition(value))
for (key, value) in statevar_dict.items())
# Build phase records if they weren't passed
if phase_records is None:
models = instantiate_models(dbf,
comps,
active_phases,
model=model,
parameters=parameters)
phase_records = build_phase_records(dbf,
comps,
active_phases,
statevar_dict,
models=models,
parameters=parameters,
output=output,
callables=callables,
build_gradients=False,
build_hessians=False,
verbose=kwargs.pop(
'verbose', False))
else:
# phase_records were provided, instantiated models must also be provided by the caller
models = model
if not isinstance(models, Mapping):
raise ValueError(
"A dictionary of instantiated models must be passed to `equilibrium` with the `model` argument if the `phase_records` argument is used."
)
active_phases_without_models = [
name for name in active_phases
if not isinstance(models.get(name), Model)
]
active_phases_without_phase_records = [
name for name in active_phases
if not isinstance(phase_records.get(name), PhaseRecord)
]
if len(active_phases_without_phase_records) > 0:
raise ValueError(
f"phase_records must contain a PhaseRecord instance for every active phase. Missing PhaseRecord objects for {sorted(active_phases_without_phase_records)}"
)
if len(active_phases_without_models) > 0:
raise ValueError(
f"model must contain a Model instance for every active phase. Missing Model objects for {sorted(active_phases_without_models)}"
)
maximum_internal_dof = max(
len(models[phase_name].site_fractions) for phase_name in active_phases)
for phase_name in sorted(active_phases):
mod = models[phase_name]
phase_record = phase_records[phase_name]
points = points_dict[phase_name]
if points is None:
points = _sample_phase_constitution(
mod, sampler_dict[phase_name] or point_sample,
fixedgrid_dict[phase_name], pdens_dict[phase_name])
points = np.atleast_2d(points)
fp = fake_points and (phase_name == sorted(active_phases)[0])
phase_ds = _compute_phase_values(nonvacant_components,
str_statevar_dict,
points,
phase_record,
output,
maximum_internal_dof,
broadcast=broadcast,
parameters=parameters,
largest_energy=float(largest_energy),
fake_points=fp)
all_phase_data.append(phase_ds)
fp_offset = len(nonvacant_elements) if fake_points else 0
running_total = [fp_offset] + list(
np.cumsum([phase_ds['X'].shape[-2] for phase_ds in all_phase_data]))
islice_by_phase = {
phase_name: slice(running_total[phase_idx],
running_total[phase_idx + 1], None)
for phase_idx, phase_name in enumerate(sorted(active_phases))
}
# speedup for single-phase case (found by profiling)
if len(all_phase_data) > 1:
concatenated_coords = all_phase_data[0].coords
data_vars = all_phase_data[0].data_vars
concatenated_data_vars = {}
for var in data_vars.keys():
data_coords = data_vars[var][0]
points_idx = data_coords.index('points') # concatenation axis
arrs = []
for phase_data in all_phase_data:
arrs.append(getattr(phase_data, var))
concat_data = np.concatenate(arrs, axis=points_idx)
concatenated_data_vars[var] = (data_coords, concat_data)
final_ds = LightDataset(data_vars=concatenated_data_vars,
coords=concatenated_coords)
else:
final_ds = all_phase_data[0]
final_ds.attrs['phase_indices'] = islice_by_phase
if to_xarray:
return final_ds.get_dataset()
else:
return final_ds
def eqplot(eq,
ax=None,
x=None,
y=None,
z=None,
tielines=True,
resize=False,
**kwargs):
"""
Plot the result of an equilibrium calculation.
The type of plot is controlled by the degrees of freedom in the equilibrium calculation.
Parameters
----------
eq : xarray.Dataset
Result of equilibrium calculation.
ax : matplotlib.Axes
Default axes used if not specified.
x : StateVariable, optional
y : StateVariable, optional
z : StateVariable, optional
tielines : bool
If True, will plot tielines
kwargs : kwargs
Passed to `matplotlib.pyplot.scatter`.
Returns
-------
matplotlib AxesSubplot
"""
# TODO: add kwargs for tie-lines with defaults
conds = OrderedDict([
(_map_coord_to_variable(key), unpack_condition(np.asarray(value)))
for key, value in sorted(eq.coords.items(), key=str)
if (key in ('T', 'P', 'N')) or (key.startswith('X_'))
])
indep_comps = sorted([
key for key, value in conds.items()
if isinstance(key, v.MoleFraction) and len(value) > 1
],
key=str)
indep_pots = [
key for key, value in conds.items()
if (type(key) is v.StateVariable) and len(value) > 1
]
# we need to wrap the axes handling in these, becase we don't know ahead of time what projection to use.
# contractually: each inner loops must
# 1. Define the ax (calling plt.gca() with the correct projection if none are passed)
# 2. Define legend_handles
if len(indep_comps) == 1 and len(indep_pots) == 1:
# binary system with composition and a potential as coordinates
ax = ax if ax is not None else plt.gca()
# find x and y, default to x=v.X and y=v.T
x = x if x is not None else indep_comps[0]
y = y if y is not None else indep_pots[0]
# Get all two phase data
x_2, y_2, labels = get_eq_axis_data(eq, x, y, 2)
if any(map(is_molar_quantity, (x, y))):
# The diagram has tie-lines that must be plotted.
legend_handles, colormap = phase_legend(sorted(np.unique(labels)))
# plot x vs. y for each phase (phase index 0 and 1)
kwargs.setdefault('s', 20)
for phase_idx in range(2):
# TODO: kwargs.setdefault('c', [colormap[ph] for ph in labels[..., phase_idx]])
ax.scatter(x_2[..., phase_idx],
y_2[..., phase_idx],
c=[colormap[ph] for ph in labels[..., phase_idx]],
**kwargs)
if tielines:
ax.plot(x_2.T, y_2.T, c=[0, 1, 0, 1], linewidth=0.5, zorder=-1)
else:
# This diagram does not have tie-lines, we plot x vs. y directly
legend_handles, colormap = phase_legend(sorted(np.unique(labels)))
kwargs.setdefault('s', 20)
# TODO: kwargs colors
colorlist = [colormap[ph] for ph in labels]
ax.scatter(x_2, y_2, c=colorlist, **kwargs)
elif len(indep_comps) == 2 and len(indep_pots) == 0:
# This is a ternary isothermal, isobaric calculation
# Default to x and y of mole fractions
x = x if x is not None else indep_comps[0]
y = y if y is not None else indep_comps[1]
# Find two and three phase data
x2, y2, labels_2 = get_eq_axis_data(eq, x, y, 2)
x3, y3, labels_3 = get_eq_axis_data(eq, x, y, 3)
if any(map(is_molar_quantity, (x, y))):
# The diagram has tie-lines that must be plotted.
if isinstance(x, v.MoleFraction) and isinstance(x, v.MoleFraction):
# Both the axes are mole fractions, so the the compositions
# form a simplex. Use Gibbs "triangular" projection.
ax = ax if ax is not None else plt.gca(projection='triangular')
# TODO: code for handling projection specific things here
ax.yaxis.label.set_rotation(60)
# Here we adjust the x coordinate of the ylabel.
# We make it reasonably comparable to the position of the xlabel from the xaxis
# As the figure size gets very large, the label approaches ~0.55 on the yaxis
# 0.55*cos(60 deg)=0.275, so that is the xcoord we are approaching.
ax.yaxis.label.set_va('baseline')
fig_x_size = ax.figure.get_size_inches()[0]
y_label_offset = 1 / fig_x_size
ax.yaxis.set_label_coords(x=(0.275 - y_label_offset), y=0.5)
else:
ax = ax if ax is not None else plt.gca()
# Plot two phase data
legend_handles, colormap = phase_legend(sorted(
np.unique(labels_2)))
kwargs.setdefault('s', 20)
# TODO: color kwargs
for phase_idx in range(2):
ax.scatter(x2[..., phase_idx],
y2[..., phase_idx],
c=[colormap[ph] for ph in labels_2[..., phase_idx]],
**kwargs)
if tielines:
# Plot tie-lines between two phases
ax.plot(x2.T, y2.T, c=[0, 1, 0, 1], linewidth=0.5, zorder=-1)
# Find and plot three phase tie-triangles
# plot lines between all three pairs of phases to form tie-triangles
for phase_idx_pair in ((0, 1), (0, 2), (1, 2)):
ax.plot(x3[:, phase_idx_pair].T,
y3[:, phase_idx_pair].T,
c=[1, 0, 0, 1],
lw=0.5,
zorder=-1)
else:
# This diagram does not have tie-lines, we plot x vs. y directly
ax = ax if ax is not None else plt.gca()
combined_labels = np.unique(labels_2).tolist() + np.unique(
labels_3).tolist()
legend_handles, colormap = phase_legend(sorted(combined_labels))
kwargs.setdefault('s', 20)
ax.scatter(x2, y2, c=[colormap[ph] for ph in labels_2], **kwargs)
ax.scatter(x3, y3, c=[colormap[ph] for ph in labels_3], **kwargs)
else:
raise ValueError(
'The eqplot projection is not defined and cannot be autodetected. There are {} independent compositions and {} indepedent potentials.'
.format(len(indep_comps), len(indep_pots)))
# position the phase legend and configure plot
if resize:
if not 'Triangular' in str(type(ax)):
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
# TODO: special limits resizing handling for different axes types
# ax.set_xlim([np.min(conds[x]) - 1e-2, np.max(conds[x]) + 1e-2])
# ax.set_ylim([np.min(conds[y]), np.max(conds[y])])
ax.tick_params(axis='both', which='major', labelsize=12)
ax.legend(handles=legend_handles,
loc='center left',
bbox_to_anchor=(1, 0.5))
comps = eq.component.values.tolist()
plot_title = '-'.join([
component.title() for component in sorted(comps) if component != 'VA'
])
ax.set_title(plot_title, fontsize=20)
ax.set_xlabel(_axis_label(x), labelpad=15, fontsize=20)
ax.set_ylabel(_axis_label(y), fontsize=20)
return ax