def bubbler(potential, backend="cosmotransitions", **kwargs):
"""
:param potential: Potential object or string
:param backend: Code with which to solve bounce
:returns: Results from a particular code
:rtype: namedtuple
"""
try:
# Call function
module = globals()[backend]
potential = Potential(potential) if isinstance(potential,
str) else potential
action, trajectory_data, time, command = module.solve(
potential, **kwargs)
# Make interpolation function from output
trajectory = [
interp(trajectory_data[:, 0], trajectory_data[:, i + 1])
for i in range(potential.n_fields)
] if trajectory_data is not None else None
# Find maximum value of rho
rho_end = trajectory_data[-1,
0] if trajectory_data is not None else None
return Solution(backend, action, trajectory, rho_end, time, command)
except Exception as error:
return Solution(backend, None, None, None, None, error.message)
def profiles(potential, backends=None, **kwargs):
"""
:param potential: Potential object or string
Plots field profiles for all codes.
"""
potential = Potential(potential) if isinstance(potential,
str) else potential
results = bubblers(potential, backends, **kwargs)
# Make profile plot
_, ax = plt.subplots()
colors = cycle(["Brown", "Green", "Blue"])
for result in results.itervalues():
if not result.action:
continue
color = next(colors)
lines = cycle(["-", "--", "-."])
rho = np.linspace(0, result.rho_end, 1000)
for name, trajectory in zip(potential.field_latex, result.trajectory):
ax.plot(rho,
trajectory(rho),
ls=next(lines),
c=color,
lw=3,
label="{} from {}".format(name, result.backend),
alpha=0.8)
# Plot true vacuum
markers = cycle(["^", "p", "*"])
for name, field in zip(potential.field_latex, potential.true_vacuum):
ax.plot(0.,
field,
next(markers),
c="Gold",
label="True vacuum for {}".format(name),
ms=10,
clip_on=False,
zorder=10)
# Labels etc
ax.set_xlabel(r"$\rho$")
ax.set_ylabel(r"$\phi$")
leg = ax.legend(numpoints=1, fontsize=12, loc='best')
leg.get_frame().set_alpha(0.5)
ax.set_title(potential.potential_latex)
plt.show()
def test_add_empty_potentials(self):
""" Potential addition with empty potential """
# first we test construction of empty potential
p = Potential()
self.assertEqual(p.labels, [])
self.assertEqual(p.nsites, 0)
self.assertEqual(p.npols, 0)
p2 = p + p # maybe we should just raise a value error instead?
self.assertEqual(p2.nsites, 0)
self.assertEqual(p2.npols, 0)
def initalize_message(self):
'''every node has a message dictionary
self.message ={j: {nodek: mkj(xj), nodeh: mhj(xj), ...},
i: {nodek: mki(xi), nodeh: mhi(xi), ...},
}
'''
self.message = {}
for node_idx, node_name in enumerate(self.graph.node_list):
self.message[node_idx] = {}
for neighbor_node in self.graph.neighbor(node_idx):
self.message[node_idx][neighbor_node] = Potential(
[node_idx], np.array([self.graph.node_size[node_idx]]),
np.ones(self.graph.node_size[node_idx]))
def bubblers(potential, backends=None, **kwargs):
"""
:param potential: Potential object or string
:param backend: Code with which to solve bounce
:returns: Results from all codes
:rtype: list of namedtuple
"""
potential = Potential(potential) if isinstance(potential,
str) else potential
backends = backends if backends else BACKENDS
return Solutions(
{b: bubbler(potential, backend=b, **kwargs)
for b in backends})
def __pb_train_click(self):
try:
class_0_point_0_x = int(self.ui.le_class_0_point_0_x.text())
class_0_point_0_y = int(self.ui.le_class_0_point_0_y.text())
point_0 = Point(class_0_point_0_x, class_0_point_0_y)
class_0_point_1_x = int(self.ui.le_class_0_point_1_x.text())
class_0_point_1_y = int(self.ui.le_class_0_point_1_y.text())
point_1 = Point(class_0_point_1_x, class_0_point_1_y)
self.__training_vectors[0] = [point_0, point_1]
except ValueError:
self.__training_vectors[0] = [Point(3, 2), Point(-5, 0)]
try:
class_1_point_0_x = int(self.ui.le_class_1_point_0_x.text())
class_1_point_0_y = int(self.ui.le_class_1_point_0_y.text())
point_0 = Point(class_1_point_0_x, class_1_point_0_y)
class_1_point_1_x = int(self.ui.le_class_1_point_1_x.text())
class_1_point_1_y = int(self.ui.le_class_1_point_1_y.text())
point_1 = Point(class_1_point_1_x, class_1_point_1_y)
self.__training_vectors[1] = [point_0, point_1]
except ValueError:
self.__training_vectors[1] = [Point(4, -7), Point(1, 1)]
potential = Potential(self.__amount_of_classes)
self.__func, isSuccess = potential.train(self.__training_vectors)
if not isSuccess:
self.__msgbox_message(
'Error',
'An error occurred while training. \nEnter another training data.'
)
else:
self.scene.clear()
self.__draw_axes()
self.__draw_graphic()
self.__draw_training_points()
try:
self.ui.le_separated_function.setText(str(self.__func))
except ValueError:
self.__msgbox_message(
'Error',
'An error occurred while training. \nEnter another training data.'
)
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
import MDAnalysis as md
from density import Density
from potential import Potential
u = md.Universe('trj/md128_280k.tpr',
'trj/md128_280k.xtc')
h2o = u.select_atoms('name OW or name HW1 or name HW2')
pot = Potential(u)
for _ in tqdm(u.trajectory, total=len(u_trajectory)):
pot.potential_matrix()
'''
plt.plot(t, np.mean(rot, axis=1), 'o')
plt.plot(ref[:,0], ref[:,2]/512, '-')
plt.xlim((0, 0.2))
plt.show()
'''
pot_surface3 = Surface_1D_analytic(np.cos, relative=True)
complete_interaction = [{
'function': pot_surface3,
'coordinates': [0, 1]
}, {
'function': pot_surface3,
'coordinates': [1, 2]
}, {
'function': pot_surface3,
'coordinates': [2, 3]
}, {
'function': pot_surface3,
'coordinates': [3, 4]
}]
pot_obj = Potential(complete_interaction)
initial_conditions = {
'coordinates': np.array([4, 0, 0, 0, 0]),
'velocity': np.array([3, 0, 0, 0, 0]),
'masses': np.array([300.0, 1.0, 1.0, 1.0, 1.0])
}
md = MolecularDynamics(initial_conditions=initial_conditions,
potential=pot_obj)
md.calculate_nve()
md.calculate_nvt()
def __init__(self, id, nodes, sizes, values=None):
self.id = id
self.potential = Potential(nodes, sizes, values)
import numpy as np
from potential import Potential
#
pot_x1 = Potential([0], np.array([2]), np.array([0.9, 0.1]))
pot_x2 = Potential([1], np.array([2]), np.array([1.0, 1.0]))
pot_x2x1 = Potential([1, 0], np.array([2, 2]),
np.array([[0.9, 0.2], [0.1, 0.8]]))
pot_x1x2 = Potential([0, 1], np.array([2, 2]),
np.array([[0.9, 0.1], [0.2, 0.8]]))
pot_m12_x2 = Potential([1], np.array([2]), np.array([0.83, 0.17]))
res1 = pot_x2x1.multiply(pot_x1)
res1_ver = Potential([1, 0], np.array([2, 2]),
np.array([[0.81, 0.02], [0.09, 0.08]]))
print res1
assert res1 == res1_ver
res2 = pot_x1x2.multiply(pot_x1)
res2_ver = Potential([0, 1], np.array([2, 2]),
np.array([[0.81, 0.09], [0.02, 0.08]]))
print res2
assert res2 == res2_ver
res3 = pot_x2.multiply(pot_m12_x2)
res3_ver = Potential([1], np.array([2]), np.array([0.83, 0.17]))
assert res3 == res3_ver
print res3
def run_test(configData):
# Example with config Data
if not configData:
print("Using configuration file: ", configData)
# Set up our potential class
# TODO: Convert potential from config file
# We will pass a dictionary that we will get from the config file. For now we construct it manually
potential_parameters = {}
# define fields and constants for the time being
# define constants
const_2, const_3, const_4 = sympy.symbols('c2,c3,c4')
constants = (const_2, const_3, const_4)
# define fields
field_1, field_2 = sympy.symbols('f1,f2')
fields = (field_1, field_2)
# Define the potential
potential_form = const_2 * field_1**2 + const_3 * field_1**3 + const_4 * field_1**4 + field_2**4
# Vevs and masses
vevs = (246., 0.)
masses = (0., 125.
) # some ordering may be required to match diagonalisation
# TODO: Are minimization bounds going to be derivived or inputs?. If inputs, put here and feed into potential parameters
# Bounds and Initial Points
# Build the dictionary
potential_parameters['fields'] = fields
potential_parameters['constants'] = constants
potential_parameters['potential_form'] = potential_form
potential_parameters['vevs'] = vevs
potential_parameters['masses'] = masses
potential_parameters['unknown_constants'] = (const_2, const_4)
potential_parameters['known_constants'] = (const_3, )
potential_parameters['known_constants_vals'] = (-1.5 * 125.**2 / 246. /
3, )
# Create our potential class
# This stores all info about the potential - See the class
potential = Potential(potential_parameters)
# potential currently cannot handle pure mass terms
# solve the constants from 1st derivative and hessian of potential
# This will be private function - But for testing lets run it
# TODO: Make sure there are no more free constants after reduction
print("==============coupling constants reduction============")
print(potential._constant_reduction)
print("======================================================")
# ####working out the free-parameters######
print("===============printing free constants================")
print(potential.remaining_vars())
print("======================================================")
# print("=====================test outputs=====================")
# # Only printing for testing. Private member
# print("Constrained Potential :", potential._constrained_potential)
#
# # Set some constants
# constant_val = {'c3': -1.5 * 125. ** 2 / 246. / 3}
# print("Potential with c3 Fixed :", potential.set_constants(constant_val))
#
# # Get Numeric Values of Constants given fixed unknown variables
# print("Numeric Values for Constants with c3 fixed :", potential.numeric_const_values(constant_val))
# print("======================================================")
# define the bounds of the minimisation, where the c20vals etc are set to fix the value
# define initial point for minimisation
# Initial point for finding minima
# Bounds for the minimization
# TODO: Implement minimization with bounds and initial point.
# TODO: Implementation is done in the class not here!
# TODO: Bounds can be class members and set up from config. Or dervived in the constructor
# bnds = ((-400., 400.), (-400., 400.), (c20val, c20val), (c30val, c30val), (c40val, c40val))
# bounds = < insert some points >
#bounds=((-400.,400),)
# run minimisation
# TODO: for each field add the range (-400.,400.)
(bounds, initial_point) = (((-400., 400), (-400., 400.)), [0., 0.])
print("=========printing solutions from minimisation=========")
#print(potential.func_to_minimise())
print(potential.minimise(bounds, initial_point))
#print(Potential.out)
print("======================================================")
# Plotting
""" Leave for Now... will fix soon
