def test_pickling(simulation_factory, two_particle_snapshot_factory):
sim = simulation_factory(two_particle_snapshot_factory())
active = hoomd.md.force.Active(filter=hoomd.filter.All())
pickling_check(active)
integrator = hoomd.md.Integrator(
.05,
methods=[hoomd.md.methods.Langevin(hoomd.filter.All(), kT=0)],
forces=[active])
sim.operations.integrator = integrator
sim.run(0)
pickling_check(active)
def test_pickling(manifold_base_params, simulation_factory,
two_particle_snapshot_factory):
sim = simulation_factory(two_particle_snapshot_factory())
manifold = manifold_base_params.surface(
**manifold_base_params.setup_params)
nve = hoomd.md.methods.NVE(filter=hoomd.filter.All(),
manifold_constraint=manifold)
integrator = hoomd.md.Integrator(0.005, methods=[nve])
sim.operations += integrator
pickling_check(manifold)
sim.run(0)
pickling_check(manifold)
def test_pickling(make_two_particle_simulation, pair_potential_spec):
pair_potential = pair_potential_spec.cls(nlist=md.nlist.Cell(), r_cut=2.5)
for key, value in pair_potential_spec.type_parameters.items():
setattr(pair_potential, key, value)
assert _equivalent_data_structures(value, getattr(pair_potential, key))
sim = make_two_particle_simulation(types=['A', 'B'],
dimensions=3,
d=0.5,
force=pair_potential)
pickling_check(pair_potential)
sim.run(0)
pickling_check(pair_potential)
def test_pickling(make_two_particle_simulation, pair_potential_spec):
pair_potential = pair_potential_spec.cls(nlist=md.nlist.Cell(buffer=0.4),
default_r_cut=2.5)
for key, value in pair_potential_spec.type_parameters.items():
setattr(pair_potential, key, value)
sim = make_two_particle_simulation(types=['A', 'B'],
dimensions=3,
d=0.5,
force=pair_potential)
pickling_check(pair_potential)
sim.run(0)
pickling_check(pair_potential)
def test_pickling(simulation_factory, two_particle_snapshot_factory,
valid_params):
sim = simulation_factory(two_particle_snapshot_factory())
_skip_if_triplet_gpu_mpi(sim, valid_params.pair_potential)
pot = valid_params.pair_potential(**valid_params.extra_args,
nlist=md.nlist.Cell(),
default_r_cut=2.5)
for pair in valid_params.pair_potential_params:
pot.params[pair] = valid_params.pair_potential_params[pair]
pickling_check(pot)
integrator = hoomd.md.Integrator(0.05, forces=[pot])
sim.operations.integrator = integrator
sim.run(0)
pickling_check(pot)
def test_pickling(simulation_factory, polymer_snapshot_factory):
"""Test that md.constrain.Distance can be pickled and unpickled."""
# detached
d = hoomd.md.constrain.Distance(tolerance=1e-5)
pickling_check(d)
# attached
sim = simulation_factory(polymer_snapshot_factory())
integrator = hoomd.md.Integrator(dt=0.005)
nve = hoomd.md.methods.NVE(filter=hoomd.filter.All())
integrator.methods.append(nve)
integrator.constraints.append(d)
sim.run(0)
pickling_check(d)
def test_pickling(method_base_params, simulation_factory,
two_particle_snapshot_factory):
method = method_base_params.method(**method_base_params.setup_params,
filter=hoomd.filter.All())
pickling_check(method)
sim = simulation_factory(two_particle_snapshot_factory())
if (method_base_params.method == hoomd.md.methods.Berendsen
and sim.device.communicator.num_ranks > 1):
pytest.skip("Berendsen method does not support multiple processor "
"configurations.")
integrator = hoomd.md.Integrator(0.05, methods=[method])
sim.operations.integrator = integrator
sim.run(0)
pickling_check(method)
def test_pickling_potential(simulation_factory, two_particle_snapshot_factory,
alchemical_potential):
"""Test that md.constrain.Distance can be pickled and unpickled."""
# detached
nlist = hoomd.md.nlist.Cell(buffer=0.4)
ljg = alchemical_potential(nlist, default_r_cut=3.0)
ljg.params[('A', 'A')] = dict(epsilon=1., sigma=0.02, r0=1.8)
pickling_check(ljg)
# attached
sim = simulation_factory(two_particle_snapshot_factory(dimensions=3, d=1))
integrator = hoomd.md.Integrator(dt=0.005)
integrator.forces.append(ljg)
sim.operations.integrator = integrator
sim.run(0)
pickling_check(ljg)
def test_pickling(simulation_factory, two_particle_snapshot_factory):
nlist = Cell(0.4)
pickling_check(nlist)
lj = hoomd.md.pair.LJ(nlist, default_r_cut=1.1)
lj.params[('A', 'A')] = dict(epsilon=1, sigma=1)
lj.params[('A', 'B')] = dict(epsilon=1, sigma=1)
lj.params[('B', 'B')] = dict(epsilon=1, sigma=1)
integrator = hoomd.md.Integrator(0.005, forces=[lj])
integrator.methods.append(
hoomd.md.methods.Langevin(hoomd.filter.All(), kT=1))
sim = simulation_factory(
two_particle_snapshot_factory(particle_types=["A", "B"], d=2.0))
sim.operations.integrator = integrator
sim.run(0)
pickling_check(nlist)
def test_pickling(simulation_factory, two_charged_particle_snapshot_factory):
"""Test that md.long_range.pppm.Coulomb can be pickled and unpickled."""
# detached
nlist = hoomd.md.nlist.Cell(buffer=0.4)
ewald, coulomb = hoomd.md.long_range.pppm.make_pppm_coulomb_forces(
nlist=nlist, resolution=(64, 64, 64), order=6, r_cut=3.0, alpha=0)
pickling_check(coulomb)
# attached
sim = simulation_factory(two_charged_particle_snapshot_factory())
integrator = hoomd.md.Integrator(dt=0.005)
nve = hoomd.md.methods.NVE(filter=hoomd.filter.All())
integrator.methods.append(nve)
integrator.forces.extend([ewald, coulomb])
sim.operations.integrator = integrator
sim.run(0)
assert ewald._attached
assert coulomb._attached
pickling_check(coulomb)
def test_pickling(typedict_pair_keys, attached_param_dict):
pickling_check(typedict_pair_keys)
pickling_check(attached_param_dict)
def test_pickling(all_, attached):
pickling_check(all_)
pickling_check(attached)
def test_pickling(slist):
pickling_check(slist)
def test_pickling(self, blank_logger, logged_obj):
blank_logger.add(logged_obj)
pickling_check(blank_logger)
def test_pickling(self, populated_collection):
test_list, _ = populated_collection
pickling_check(test_list)
def test_pickling(full_op, attached):
pickling_check(full_op)
pickling_check(attached)
def test_pickling(variant):
# This also tests equality of objects with the same attributes
pickling_check(variant)
def test_pickling(self, populated_collection):
pickling_check(populated_collection[0])
