def test_complex_infinity_can_build_callables_successfully():
"""Test that functions that containing complex infinity can be built with codegen."""
mod = Model(C_FE_DBF, ['C'], 'DIAMOND_A4')
mod_vars = [v.N, v.P, v.T] + mod.site_fractions
# Test builds functions only, since functions takes about 1 second to run.
# Both lambda and llvm backends take a few seconds to build the derivatives
# and are probably unnecessary to test.
assert zoo in list(mod.GM.atoms())
build_functions(mod.GM, mod_vars, include_obj=True, include_grad=False, include_hess=False)
int_cons = mod.get_internal_constraints()
build_constraint_functions(mod_vars, int_cons)
def test_build_functions_options():
"""The correct SymEngine backend can be chosen for build_functions"""
mod = Model(ALNIPT_DBF, ['AL'], 'LIQUID')
int_cons = mod.get_internal_constraints()
backend = 'lambda'
fs_lambda = build_functions(mod.GM,
mod.GM.free_symbols,
include_obj=True,
func_options={'backend': backend},
include_grad=True,
grad_options={'backend': backend},
include_hess=True,
hess_options={'backend': backend})
assert isinstance(fs_lambda.func, LambdaDouble)
assert isinstance(fs_lambda.grad, LambdaDouble)
assert isinstance(fs_lambda.hess, LambdaDouble)
cfs_lambda = build_constraint_functions(mod.GM.free_symbols,
int_cons,
func_options={'backend': backend},
jac_options={'backend': backend},
hess_options={'backend': backend})
assert isinstance(cfs_lambda.cons_func, LambdaDouble)
assert isinstance(cfs_lambda.cons_jac, LambdaDouble)
assert isinstance(cfs_lambda.cons_hess, LambdaDouble)
backend = 'llvm'
fs_llvm = build_functions(mod.GM,
mod.GM.free_symbols,
include_obj=True,
func_options={'backend': backend},
include_grad=True,
grad_options={'backend': backend},
include_hess=True,
hess_options={'backend': backend})
print(fs_llvm.func)
print(fs_lambda.func)
assert isinstance(fs_llvm.func, LLVMDouble)
assert isinstance(fs_llvm.grad, LLVMDouble)
assert isinstance(fs_llvm.hess, LLVMDouble)
cfs_llvm = build_constraint_functions(mod.GM.free_symbols,
int_cons,
func_options={'backend': backend},
jac_options={'backend': backend},
hess_options={'backend': backend})
assert isinstance(cfs_llvm.cons_func, LLVMDouble)
assert isinstance(cfs_llvm.cons_jac, LLVMDouble)
assert isinstance(cfs_llvm.cons_hess, LLVMDouble)
def build_callables(dbf, comps, phases, models, parameter_symbols=None,
output='GM', build_gradients=True, build_hessians=False,
additional_statevars=None):
"""
Create a compiled callables dictionary.
Parameters
----------
dbf : Database
A Database object
comps : list
List of component names
phases : list
List of phase names
models : dict
Dictionary of {phase_name: Model subclass}
parameter_symbols : list, optional
List of string or SymPy Symbols that will be overridden in the callables.
output : str, optional
Output property of the particular Model to sample. Defaults to 'GM'
build_gradients : bool, optional
Whether or not to build gradient functions. Defaults to True.
build_hessians : bool, optional
Whether or not to build Hessian functions. Defaults to False.
additional_statevars : set, optional
State variables to include in the callables that may not be in the models (e.g. from conditions)
verbose : bool, optional
Print the name of the phase when its callables are built
Returns
-------
callables : dict
Dictionary of keyword argument callables to pass to equilibrium.
Maps {'output' -> {'function' -> {'phase_name' -> AutowrapFunction()}}.
Notes
-----
*All* the state variables used in calculations must be specified.
If these are not specified as state variables of the models (e.g. often the
case for v.N), then it must be supplied by the additional_statevars keyword
argument.
Examples
--------
>>> from pycalphad import Database, equilibrium, variables as v
>>> from pycalphad.codegen.callables import build_callables
>>> from pycalphad.core.utils import instantiate_models
>>> dbf = Database('AL-NI.tdb')
>>> comps = ['AL', 'NI', 'VA']
>>> phases = ['LIQUID', 'AL3NI5', 'AL3NI2', 'AL3NI']
>>> models = instantiate_models(dbf, comps, phases)
>>> callables = build_callables(dbf, comps, phases, models, additional_statevars={v.P, v.T, v.N})
>>> 'GM' in callables.keys()
True
>>> 'massfuncs' in callables['GM']
True
>>> conditions = {v.P: 101325, v.T: 2500, v.X('AL'): 0.2}
>>> equilibrium(dbf, comps, phases, conditions, callables=callables)
"""
additional_statevars = set(additional_statevars) if additional_statevars is not None else set()
parameter_symbols = parameter_symbols if parameter_symbols is not None else []
parameter_symbols = sorted([wrap_symbol(x) for x in parameter_symbols], key=str)
comps = sorted(unpack_components(dbf, comps))
pure_elements = get_pure_elements(dbf, comps)
_callables = {
'massfuncs': {},
'massgradfuncs': {},
'masshessfuncs': {},
'callables': {},
'grad_callables': {},
'hess_callables': {},
'internal_cons': {},
'internal_jac': {},
'internal_cons_hess': {},
'mp_cons': {},
'mp_jac': {},
}
state_variables = get_state_variables(models=models)
state_variables |= additional_statevars
if state_variables != {v.T, v.P, v.N}:
warnings.warn("State variables in `build_callables` are not {{N, P, T}}, "
"but {}. Be sure you know what you are doing. "
"State variables can be added with the `additional_statevars` "
"argument.".format(state_variables))
state_variables = sorted(state_variables, key=str)
for name in phases:
mod = models[name]
site_fracs = mod.site_fractions
try:
out = getattr(mod, output)
except AttributeError:
raise AttributeError('Missing Model attribute {0} specified for {1}'
.format(output, mod.__class__))
# Build the callables of the output
# Only force undefineds to zero if we're not overriding them
undefs = {x for x in out.free_symbols if not isinstance(x, v.StateVariable)} - set(parameter_symbols)
undef_vals = repeat(0., len(undefs))
out = out.xreplace(dict(zip(undefs, undef_vals)))
build_output = build_functions(out, tuple(state_variables + site_fracs), parameters=parameter_symbols,
include_grad=build_gradients, include_hess=build_hessians)
cf, gf, hf = build_output.func, build_output.grad, build_output.hess
_callables['callables'][name] = cf
_callables['grad_callables'][name] = gf
_callables['hess_callables'][name] = hf
# Build the callables for mass
# TODO: In principle, we should also check for undefs in mod.moles()
mcf, mgf, mhf = zip(*[build_functions(mod.moles(el), state_variables + site_fracs,
include_obj=True,
include_grad=build_gradients,
include_hess=build_hessians,
parameters=parameter_symbols)
for el in pure_elements])
_callables['massfuncs'][name] = mcf
_callables['massgradfuncs'][name] = mgf
_callables['masshessfuncs'][name] = mhf
return {output: _callables}
def build_callables(dbf,
comps,
phases,
models,
parameter_symbols=None,
output='GM',
build_gradients=True,
build_hessians=False,
additional_statevars=None):
"""
Create a compiled callables dictionary.
Parameters
----------
dbf : Database
A Database object
comps : list
List of component names
phases : list
List of phase names
models : dict
Dictionary of {phase_name: Model subclass}
parameter_symbols : list, optional
List of string or SymPy Symbols that will be overridden in the callables.
output : str, optional
Output property of the particular Model to sample. Defaults to 'GM'
build_gradients : bool, optional
Whether or not to build gradient functions. Defaults to True.
build_hessians : bool, optional
Whether or not to build Hessian functions. Defaults to False.
additional_statevars : set, optional
State variables to include in the callables that may not be in the models (e.g. from conditions)
verbose : bool, optional
Print the name of the phase when its callables are built
Returns
-------
callables : dict
Dictionary of keyword argument callables to pass to equilibrium.
Maps {'output' -> {'function' -> {'phase_name' -> AutowrapFunction()}}.
Notes
-----
*All* the state variables used in calculations must be specified.
If these are not specified as state variables of the models (e.g. often the
case for v.N), then it must be supplied by the additional_statevars keyword
argument.
Examples
--------
>>> from pycalphad import Database, equilibrium, variables as v
>>> from pycalphad.codegen.callables import build_callables
>>> from pycalphad.core.utils import instantiate_models
>>> dbf = Database('AL-NI.tdb')
>>> comps = ['AL', 'NI', 'VA']
>>> phases = ['LIQUID', 'AL3NI5', 'AL3NI2', 'AL3NI']
>>> models = instantiate_models(dbf, comps, phases)
>>> callables = build_callables(dbf, comps, phases, models, additional_statevars={v.P, v.T, v.N})
>>> 'GM' in callables.keys()
True
>>> 'massfuncs' in callables['GM']
True
>>> conditions = {v.P: 101325, v.T: 2500, v.X('AL'): 0.2}
>>> equilibrium(dbf, comps, phases, conditions, callables=callables)
"""
additional_statevars = set(
additional_statevars) if additional_statevars is not None else set()
parameter_symbols = parameter_symbols if parameter_symbols is not None else []
parameter_symbols = sorted([wrap_symbol(x) for x in parameter_symbols],
key=str)
comps = sorted(unpack_components(dbf, comps))
pure_elements = get_pure_elements(dbf, comps)
_callables = {
'massfuncs': {},
'massgradfuncs': {},
'masshessfuncs': {},
'callables': {},
'grad_callables': {},
'hess_callables': {},
'internal_cons_func': {},
'internal_cons_jac': {},
'internal_cons_hess': {},
'multiphase_cons_func': {},
'multiphase_cons_jac': {},
'multiphase_cons_hess': {}
}
state_variables = get_state_variables(models=models)
state_variables |= additional_statevars
if state_variables != {v.T, v.P, v.N}:
warnings.warn(
"State variables in `build_callables` are not {{N, P, T}}, but {}. This can lead to incorrectly "
"calculated values if the state variables used to call the generated functions do not match the "
"state variables used to create them. State variables can be added with the "
"`additional_statevars` argument.".format(state_variables))
state_variables = sorted(state_variables, key=str)
for name in phases:
mod = models[name]
site_fracs = mod.site_fractions
try:
out = getattr(mod, output)
except AttributeError:
raise AttributeError(
'Missing Model attribute {0} specified for {1}'.format(
output, mod.__class__))
# Build the callables of the output
# Only force undefineds to zero if we're not overriding them
undefs = {
x
for x in out.free_symbols if not isinstance(x, v.StateVariable)
} - set(parameter_symbols)
undef_vals = repeat(0., len(undefs))
out = out.xreplace(dict(zip(undefs, undef_vals)))
build_output = build_functions(out,
tuple(state_variables + site_fracs),
parameters=parameter_symbols,
include_grad=build_gradients,
include_hess=build_hessians)
cf, gf, hf = build_output.func, build_output.grad, build_output.hess
_callables['callables'][name] = cf
_callables['grad_callables'][name] = gf
_callables['hess_callables'][name] = hf
# Build the callables for mass
# TODO: In principle, we should also check for undefs in mod.moles()
mcf, mgf, mhf = zip(*[
build_functions(mod.moles(el),
state_variables + site_fracs,
include_obj=True,
include_grad=build_gradients,
include_hess=build_hessians,
parameters=parameter_symbols)
for el in pure_elements
])
_callables['massfuncs'][name] = mcf
_callables['massgradfuncs'][name] = mgf
_callables['masshessfuncs'][name] = mhf
return {output: _callables}
def build_callables(dbf,
comps,
phases,
model=None,
parameters=None,
callables=None,
output='GM',
build_gradients=True,
verbose=False):
"""
Create dictionaries of callable dictionaries and PhaseRecords.
Parameters
----------
dbf : Database
A Database object
comps : list
List of component names
phases : list
List of phase names
model : dict or type
Dictionary of {phase_name: Model subclass} or a type corresponding to a
Model subclass. Defaults to ``Model``.
parameters : dict, optional
Maps SymPy Symbol to numbers, for overriding the values of parameters in the Database.
callables : dict, optional
Pre-computed callables
output : str
Output property of the particular Model to sample
build_gradients : bool
Whether or not to build gradient functions. Defaults to True.
verbose : bool
Print the name of the phase when its callables are built
Returns
-------
callables : dict
Dictionary of keyword argument callables to pass to equilibrium.
Example
-------
>>> dbf = Database('AL-NI.tdb')
>>> comps = ['AL', 'NI', 'VA']
>>> phases = ['FCC_L12', 'BCC_B2', 'LIQUID', 'AL3NI5', 'AL3NI2', 'AL3NI']
>>> callables = build_callables(dbf, comps, phases)
>>> equilibrium(dbf, comps, phases, conditions, **callables)
"""
parameters = parameters if parameters is not None else {}
if len(parameters) > 0:
param_symbols, param_values = zip(*[(key, val) for key, val in sorted(
parameters.items(), key=operator.itemgetter(0))])
param_values = np.asarray(param_values, dtype=np.float64)
else:
param_symbols = []
param_values = np.empty(0)
comps = sorted(unpack_components(dbf, comps))
pure_elements = get_pure_elements(dbf, comps)
callables = callables if callables is not None else {}
_callables = {
'massfuncs': {},
'massgradfuncs': {},
'callables': {},
'grad_callables': {}
}
models = unpack_kwarg(model, default_arg=Model)
param_symbols = [wrap_symbol(sym) for sym in param_symbols]
phase_records = {}
# create models
for name in phases:
mod = models[name]
if isinstance(mod, type):
models[name] = mod = mod(dbf,
comps,
name,
parameters=param_symbols)
site_fracs = mod.site_fractions
variables = sorted(site_fracs, key=str)
try:
out = getattr(mod, output)
except AttributeError:
raise AttributeError(
'Missing Model attribute {0} specified for {1}'.format(
output, mod.__class__))
if callables.get('callables', {}).get(name, False) and \
((not build_gradients) or callables.get('grad_callables',{}).get(name, False)):
_callables['callables'][name] = callables['callables'][name]
if build_gradients:
_callables['grad_callables'][name] = callables[
'grad_callables'][name]
else:
_callables['grad_callables'][name] = None
else:
# Build the callables of the output
# Only force undefineds to zero if we're not overriding them
undefs = {
x
for x in out.free_symbols
if not isinstance(x, v.StateVariable)
} - set(param_symbols)
undef_vals = repeat(0., len(undefs))
out = out.xreplace(dict(zip(undefs, undef_vals)))
build_output = build_functions(out,
tuple([v.P, v.T] + site_fracs),
parameters=param_symbols,
include_grad=build_gradients)
if build_gradients:
cf, gf = build_output
else:
cf = build_output
gf = None
_callables['callables'][name] = cf
_callables['grad_callables'][name] = gf
if callables.get('massfuncs', {}).get(name, False) and \
((not build_gradients) or callables.get('massgradfuncs', {}).get(name, False)):
_callables['massfuncs'][name] = callables['massfuncs'][name]
if build_gradients:
_callables['massgradfuncs'][name] = callables['massgradfuncs'][
name]
else:
_callables['massgradfuncs'][name] = None
else:
# Build the callables for mass
# TODO: In principle, we should also check for undefs in mod.moles()
if build_gradients:
mcf, mgf = zip(*[
build_functions(mod.moles(el), [v.P, v.T] + variables,
include_obj=True,
include_grad=build_gradients,
parameters=param_symbols)
for el in pure_elements
])
else:
mcf = tuple([
build_functions(mod.moles(el), [v.P, v.T] + variables,
include_obj=True,
include_grad=build_gradients,
parameters=param_symbols)
for el in pure_elements
])
mgf = None
_callables['massfuncs'][name] = mcf
_callables['massgradfuncs'][name] = mgf
if not callables.get('phase_records', {}).get(name, False):
pv = param_values
else:
# Copy parameter values from old PhaseRecord, if it exists
pv = callables['phase_records'][name].parameters
phase_records[name.upper()] = PhaseRecord_from_cython(
comps, variables,
np.array(dbf.phases[name].sublattices, dtype=np.float), pv,
_callables['callables'][name], _callables['grad_callables'][name],
_callables['massfuncs'][name], _callables['massgradfuncs'][name])
if verbose:
print(name + ' ')
# Update PhaseRecords with any user-specified parameter values, in case we skipped the build phase
# We assume here that users know what they are doing, and pass compatible combinations of callables and parameters
# See discussion in gh-192 for details
if len(param_values) > 0:
for prx_name in phase_records:
if len(phase_records[prx_name].parameters) != len(param_values):
raise ValueError(
'User-specified callables and parameters are incompatible')
phase_records[prx_name].parameters = param_values
# finally, add the models to the callables
_callables['model'] = dict(models)
_callables['phase_records'] = phase_records
return _callables