def __init__(self,
name="ParametricPotential",
expression='a*x+b',
parameters=None,
independent_variables=None,
topology=None,
**kwargs):
if expression is None:
expression = 'a*x+b'
if parameters is None:
parameters = {
'a': 1.0 * u.dimensionless,
'b': 1.0 * u.dimensionless
}
if independent_variables is None:
independent_variables = {'x'}
_potential_expression = _PotentialExpression(
expression=expression,
independent_variables=independent_variables,
parameters=parameters)
super().__init__(name=name,
potential_expression=_potential_expression,
topology=topology,
**kwargs)
def test_expression_equality(self):
expression_1 = _PotentialExpression(expression='exp(2)+exp(4)+2*phi',
independent_variables={'phi'})
expression_2 = _PotentialExpression(
expression='exp(4) + exp(2) + phi*2',
independent_variables={'phi'})
expression_3 = _PotentialExpression(
expression='exp(4) + exp(2) + phi * 8',
independent_variables={'phi'})
assert expression_1.expression == expression_2.expression
assert hash(expression_1) == hash(expression_2)
assert expression_3 != expression_2
assert expression_1 != expression_3
def __init__(
self,
name="Potential",
expression="a*x+b",
independent_variables=None,
potential_expression=None,
**kwargs,
):
if potential_expression is None:
if expression is None:
expression = "a*x+b"
if independent_variables is None:
independent_variables = {"x"}
potential_expression = _PotentialExpression(
expression=expression,
independent_variables=independent_variables,
parameters=None,
)
MetadataMixin.__init__(self, tags=kwargs.get("tags"))
GMSOBase.__init__(self,
name=name,
potential_expression=potential_expression,
**kwargs)
def test_set_indep_variables(self):
expression = _PotentialExpression(expression='a^2+2*a*b+b^2',
independent_variables='a',
parameters=None)
expression.independent_variables = {'b'}
assert sympy.Symbol('b') in expression.independent_variables
assert sympy.Symbol('a') not in expression.independent_variables
def __init__(self,
name="Potential",
expression='a*x+b',
parameters=None,
independent_variables=None,
template=False,
topology=None):
self._name = name
if expression is None:
expression = 'a*x+b'
if parameters is None:
parameters = {
'a': 1.0 * u.dimensionless,
'b': 1.0 * u.dimensionless
}
if independent_variables is None:
independent_variables = {'x'}
if template:
self._template = template
parameters = None
self._potential_expression = _PotentialExpression(
expression=expression,
independent_variables=independent_variables,
parameters=parameters)
if topology is not None:
self._topology = topology
else:
self._topology = None
def test_set_expression(self):
expression = _PotentialExpression(
"a^x + b^y + c^z",
independent_variables={"x", "y", "z"},
parameters={"a": 2.6 * u.nm, "b": 2.7 * u.nm, "c": 22.8 * u.hertz},
)
expression.expression = "a^(2*x) + b^(2*y) + c^(2*z)"
assert sympy.Symbol("x") in expression.independent_variables
def test_invalid_indep_vars(self):
with pytest.raises(ValueError) as e:
expression = _PotentialExpression(expression='a*x+b',
independent_variables='j',
parameters=None)
assert "symbol j is not in expression's free symbols Cannot " \
"use an independent variable that doesn't exist in the " \
"expression's free symbols {x, a, b}" in e
def test_non_parametric_expression(self):
expression = _PotentialExpression(expression='a^2+2*a*b+b^2',
independent_variables='a',
parameters=None)
assert expression.is_parametric is False
with pytest.raises(AttributeError) as e:
assert expression.parameters
assert 'Object of type _PotentialExpression ' \
'has no attribute parameters' in e
def test_set_indep_variables(self):
expression = _PotentialExpression(
expression="a^2+2*a*b+b^2",
independent_variables="a",
parameters=None,
)
expression.independent_variables = {"b"}
assert sympy.Symbol("b") in expression.independent_variables
assert sympy.Symbol("a") not in expression.independent_variables
def test_set_indep_variables_invalid(self):
expression = _PotentialExpression(expression='a^2+2*a*b+b^2',
independent_variables='a',
parameters=None)
with pytest.raises(ValueError) as e:
expression.independent_variables = 'y'
assert expression.independent_variables == {sympy.Symbol('a')}
def test_invalid_expression(self):
with pytest.raises(ValueError) as e:
expression = _PotentialExpression(expression='a*x+b',
independent_variables='x',
parameters={
'sigma': 1.0 * u.nm,
'phi': 1.0 * u.rad
})
assert 'ValueError: Missing necessary dependencies to ' \
'evaluate potential expression. Missing symbols: {b, a}' in e
def test_set_expression_invalid(self):
expression = _PotentialExpression(
"a^x + b^y + c^z",
independent_variables={"x", "y", "z"},
parameters={"a": 2.6 * u.nm, "b": 2.7 * u.nm, "c": 22.8 * u.hertz},
)
with pytest.raises(ValueError) as e:
expression.expression = "2 * theta^2 + 3 * phi^2"
assert sympy.sympify("a^x + b^y + c^z") == expression.expression
def test_set_expression(self):
expression = _PotentialExpression(
'a^x + b^y + c^z',
independent_variables={'x', 'y', 'z'},
parameters={
'a': 2.6 * u.nm,
'b': 2.7 * u.nm,
'c': 22.8 * u.hertz
})
expression.expression = 'a^(2*x) + b^(2*y) + c^(2*z)'
assert sympy.Symbol('x') in expression.independent_variables
def test_set_indep_variables_invalid(self):
expression = _PotentialExpression(
expression="a^2+2*a*b+b^2",
independent_variables="a",
parameters=None,
)
with pytest.raises(ValueError) as e:
expression.independent_variables = "y"
assert expression.independent_variables == {sympy.Symbol("a")}
def test_invalid_expression(self):
with pytest.raises(ValueError) as e:
expression = _PotentialExpression(
expression="a*x+b",
independent_variables="x",
parameters={"sigma": 1.0 * u.nm, "phi": 1.0 * u.rad},
)
assert (
"ValueError: Missing necessary dependencies to "
"evaluate potential expression. Missing symbols: {b, a}" in e
)
def test_parametric_equality(self):
expression_1 = _PotentialExpression(
expression='e^2+e^4+2*phi',
independent_variables={'phi'},
parameters={'e': 2.2400 * u.dimensionless})
expression_2 = _PotentialExpression(
expression='e^4 + e^2 + phi*2',
independent_variables={'phi'},
parameters={'e': 2.2400 * u.dimensionless})
expression_3 = _PotentialExpression(
expression='e^4 + e^2 + phi * 8',
independent_variables={'phi'},
parameters={'e': 2.2400 * u.dimensionless})
assert expression_1.expression == expression_2.expression
assert hash(expression_1) == hash(expression_2)
assert expression_3 != expression_2
assert expression_1 != expression_3
def test_expression(self):
expression = _PotentialExpression(
expression="a*x+b",
independent_variables="x",
parameters={"a": 1.0 * u.dimensionless, "b": 2.0 * u.dimensionless},
)
assert expression.expression == sympy.sympify("a*x+b")
assert "a" in expression.parameters.keys()
assert "b" in expression.parameters.keys()
assert expression.parameters["a"] == 1.0 * u.dimensionless
assert expression.parameters["b"] == 2.0 * u.dimensionless
def test_expression_multiple_indep_vars(self):
expression = _PotentialExpression(
expression="a^2+2*a*b+b^2+2*theta*phi",
independent_variables={"theta", "phi"},
parameters={"a": 2.0 * u.nm, "b": 2.0 * u.rad},
)
theta = sympy.Symbol("theta")
phi = sympy.Symbol("phi")
assert theta in expression.independent_variables
assert phi in expression.independent_variables
assert theta in expression.expression.free_symbols
assert phi in expression.expression.free_symbols
def test_non_parametric_expression(self):
expression = _PotentialExpression(
expression="a^2+2*a*b+b^2",
independent_variables="a",
parameters=None,
)
assert expression.is_parametric is False
with pytest.raises(AttributeError) as e:
assert expression.parameters
assert (
"Object of type _PotentialExpression "
"has no attribute parameters" in e
)
def test_expression(self):
expression = _PotentialExpression(expression='a*x+b',
independent_variables='x',
parameters={
'a': 1.0 * u.dimensionless,
'b': 2.0 * u.dimensionless
})
assert expression.expression == sympy.sympify('a*x+b')
assert 'a' in expression.parameters.keys()
assert 'b' in expression.parameters.keys()
assert expression.parameters['a'] == 1.0 * u.dimensionless
assert expression.parameters['b'] == 2.0 * u.dimensionless
def test_set_expression_invalid(self):
expression = _PotentialExpression(
'a^x + b^y + c^z',
independent_variables={'x', 'y', 'z'},
parameters={
'a': 2.6 * u.nm,
'b': 2.7 * u.nm,
'c': 22.8 * u.hertz
})
with pytest.raises(ValueError) as e:
expression.expression = '2 * theta^2 + 3 * phi^2'
assert sympy.sympify('a^x + b^y + c^z') == expression.expression
def test_parametric_equality(self):
expression_1 = _PotentialExpression(
expression="e^2+e^4+2*phi",
independent_variables={"phi"},
parameters={"e": 2.2400 * u.dimensionless},
)
expression_2 = _PotentialExpression(
expression="e^4 + e^2 + phi*2",
independent_variables={"phi"},
parameters={"e": 2.2400 * u.dimensionless},
)
expression_3 = _PotentialExpression(
expression="e^4 + e^2 + phi * 8",
independent_variables={"phi"},
parameters={"e": 2.2400 * u.dimensionless},
)
assert expression_1.expression == expression_2.expression
assert hash(expression_1) == hash(expression_2)
assert expression_3 != expression_2
assert expression_1 != expression_3
def test_expression_multiple_indep_vars(self):
expression = _PotentialExpression(
expression='a^2+2*a*b+b^2+2*theta*phi',
independent_variables={'theta', 'phi'},
parameters={
'a': 2.0 * u.nm,
'b': 2.0 * u.rad
})
theta = sympy.Symbol('theta')
phi = sympy.Symbol('phi')
assert theta in expression.independent_variables
assert phi in expression.independent_variables
assert theta in expression.expression.free_symbols
assert phi in expression.expression.free_symbols
def test_set_parameters(self):
expression = _PotentialExpression(
"a^x + b^y + c^z",
independent_variables={"x", "y", "z"},
parameters={"a": 2.6 * u.nm, "b": 2.7 * u.nm, "c": 22.8 * u.hertz},
)
expression.parameters = {
"a": 2.7 * u.nm,
"b": 2.8 * u.nm,
"c": 220.0 * u.hertz,
}
assert expression.parameters["a"] == u.unyt_quantity(2.7, units="nm")
assert expression.parameters["b"] == u.unyt_quantity(2.8, units="nm")
assert expression.parameters["c"] == u.unyt_quantity(
220.0, units="hertz"
)
def test_set_parameters(self):
expression = _PotentialExpression(
'a^x + b^y + c^z',
independent_variables={'x', 'y', 'z'},
parameters={
'a': 2.6 * u.nm,
'b': 2.7 * u.nm,
'c': 22.8 * u.hertz
})
expression.parameters = {
'a': 2.7 * u.nm,
'b': 2.8 * u.nm,
'c': 220.0 * u.hertz
}
assert expression.parameters['a'] == u.unyt_quantity(2.7, units='nm')
assert expression.parameters['b'] == u.unyt_quantity(2.8, units='nm')
assert expression.parameters['c'] == u.unyt_quantity(220.0,
units='hertz')
def test_set_parameters_invalid(self):
expression = _PotentialExpression(
"a^x + b^y + c^z",
independent_variables={"x", "y", "z"},
parameters={"a": 2.6 * u.nm, "b": 2.7 * u.nm, "c": 22.8 * u.hertz},
)
with pytest.raises(ValueError):
expression.parameters = {
"l": 2.7 * u.nm,
"m": 2.8 * u.nm,
"n": 220.0 * u.hertz,
}
assert expression.parameters["a"] == u.unyt_quantity(2.6, units="nm")
assert expression.parameters["b"] == u.unyt_quantity(2.7, units="nm")
assert expression.parameters["c"] == u.unyt_quantity(
22.8, units="hertz"
)
assert "l" not in expression.parameters
def __init__(self,
name='Potential',
expression='a*x+b',
independent_variables=None,
potential_expression=None,
**kwargs):
if potential_expression is None:
if expression is None:
expression = 'a*x+b'
if independent_variables is None:
independent_variables = {'x'}
potential_expression = _PotentialExpression(
expression=expression,
independent_variables=independent_variables,
parameters=None)
super().__init__(name=name,
potential_expression=potential_expression,
**kwargs)
def test_set_parameters_invalid(self):
expression = _PotentialExpression(
'a^x + b^y + c^z',
independent_variables={'x', 'y', 'z'},
parameters={
'a': 2.6 * u.nm,
'b': 2.7 * u.nm,
'c': 22.8 * u.hertz
})
with pytest.raises(ValueError):
expression.parameters = {
'l': 2.7 * u.nm,
'm': 2.8 * u.nm,
'n': 220.0 * u.hertz
}
assert expression.parameters['a'] == u.unyt_quantity(2.6, units='nm')
assert expression.parameters['b'] == u.unyt_quantity(2.7, units='nm')
assert expression.parameters['c'] == u.unyt_quantity(22.8,
units='hertz')
assert 'l' not in expression.parameters
def __init__(
self,
name="PotentialTemplate",
expression="4*epsilon*((sigma/r)**12 - (sigma/r)**6)",
independent_variables="r",
potential_expression=None,
template=True,
):
if not isinstance(independent_variables, set):
independent_variables = set(independent_variables.split(","))
if potential_expression is None:
_potential_expression = _PotentialExpression(
expression=expression,
independent_variables=independent_variables,
)
else:
_potential_expression = potential_expression
super(PotentialTemplate,
self).__init__(name=name,
potential_expression=_potential_expression)
def __init__(self,
name='Potential',
expression='a*x+b',
independent_variables=None,
potential_expression=None,
**kwargs):
if potential_expression is None:
if expression is None:
expression = 'a*x+b'
if independent_variables is None:
independent_variables = {'x'}
potential_expression = _PotentialExpression(
expression=expression,
independent_variables=independent_variables,
parameters=None)
MetadataMixin.__init__(self, tags=kwargs.get('tags'))
GMSOBase.__init__(self,
name=name,
potential_expression=potential_expression,
**kwargs)
