def run(nranks):
u = mir.Mirheo(nranks,
snapshot='snapshot',
debug_level=3,
log_filename='log',
no_splash=True)
u.run(402)
def run(args):
"""The `mirheo run` command.
Usage:
run [--ranks NX NY NZ]
([--num-timesteps NUM]|[--num-timesteps-attr ATTR_NAME])
snapshot_path
"""
if bool(args.num_timesteps is not None) == bool(args.num_timesteps_attr):
raise ValueError(
"Exactly one of --num-timesteps and --num-timesteps-attr must be set."
)
u = mirheo.Mirheo(args.ranks,
snapshot=args.snapshot,
debug_level=3,
log_filename='log')
if args.num_timesteps_attr:
num_timesteps = int(u.getAttribute(args.num_timesteps_attr))
else:
num_timesteps = args.num_timesteps
u.run(num_timesteps)
if args.final_snapshot:
u.saveSnapshot(args.final_snapshot)
def run(niter, statsFname, comm_address):
dt = 0.001
ranks = (2, 1, 1)
domain = (12, 8, 10)
u = mir.Mirheo(ranks,
domain,
debug_level=8,
log_filename='log',
comm_ptr=comm_address)
pv = mir.ParticleVectors.ParticleVector('pv', mass=1)
ic = mir.InitialConditions.Uniform(number_density=2)
u.registerParticleVector(pv=pv, ic=ic)
dpd = mir.Interactions.Pairwise('dpd',
rc=1.0,
kind="DPD",
a=10.0,
gamma=10.0,
kBT=1.0,
power=0.5)
u.registerInteraction(dpd)
u.setInteraction(dpd, pv, pv)
vv = mir.Integrators.VelocityVerlet('vv')
u.registerIntegrator(vv)
u.setIntegrator(vv, pv)
u.registerPlugins(mir.Plugins.createStats('stats', statsFname, 1000))
u.run(niter, dt=dt)
def create_ellipsoid(density, axes, niter):
import mirheo as mir
def recenter(coords, com):
coords = [[r[0] - com[0], r[1] - com[1], r[2] - com[2]]
for r in coords]
return coords
dt = 0.001
axes = tuple(axes)
ranks = (1, 1, 1)
fact = 3
domain = (fact * axes[0], fact * axes[1], fact * axes[2])
u = mir.Mirheo(ranks,
domain,
debug_level=3,
log_filename='log',
no_splash=True)
dpd = mir.Interactions.Pairwise('dpd',
rc=1.0,
kind="DPD",
a=10.0,
gamma=10.0,
kBT=0.5,
power=0.5)
vv = mir.Integrators.VelocityVerlet('vv')
coords = [[-axes[0], -axes[1], -axes[2]], [axes[0], axes[1], axes[2]]]
com_q = [[0.5 * domain[0], 0.5 * domain[1], 0.5 * domain[2], 1., 0, 0, 0]]
fake_oV = mir.ParticleVectors.RigidEllipsoidVector('OV',
mass=1,
object_size=len(coords),
semi_axes=axes)
fake_ic = mir.InitialConditions.Rigid(com_q=com_q, coords=coords)
belonging_checker = mir.BelongingCheckers.Ellipsoid("ellipsoidChecker")
pv_ell = u.makeFrozenRigidParticles(belonging_checker,
fake_oV,
fake_ic, [dpd],
vv,
density,
1.0,
dt=dt,
nsteps=niter)
if pv_ell:
frozen_coords = pv_ell.getCoordinates()
frozen_coords = recenter(frozen_coords, com_q[0])
else:
frozen_coords = [[]]
if u.isMasterTask():
return frozen_coords
else:
return None
def create_cylinder(density, R, L, niter):
import mirheo as mir
def recenter(coords, com):
coords = [[r[0] - com[0], r[1] - com[1], r[2] - com[2]]
for r in coords]
return coords
dt = 0.001
ranks = (1, 1, 1)
fact = 3
domain = (fact * R, fact * R, fact * L / 2)
u = mir.Mirheo(ranks,
domain,
debug_level=3,
log_filename='log',
no_splash=True)
dpd = mir.Interactions.Pairwise('dpd',
rc=1.0,
kind="DPD",
a=10.0,
gamma=10.0,
kBT=0.5,
power=0.5)
vv = mir.Integrators.VelocityVerlet('vv')
coords = [[-R, -R, -L / 2], [R, R, L / 2]]
com_q = [[0.5 * domain[0], 0.5 * domain[1], 0.5 * domain[2], 1., 0, 0, 0]]
fake_oV = mir.ParticleVectors.RigidCylinderVector('OV',
mass=1,
object_size=len(coords),
radius=R,
length=L)
fake_ic = mir.InitialConditions.Rigid(com_q, coords)
belonging_checker = mir.BelongingCheckers.Cylinder("checker")
pv_cyl = u.makeFrozenRigidParticles(belonging_checker,
fake_oV,
fake_ic, [dpd],
vv,
density,
1.0,
dt=dt,
nsteps=niter)
if pv_cyl:
frozen_coords = pv_cyl.getCoordinates()
frozen_coords = recenter(frozen_coords, com_q[0])
else:
frozen_coords = [[]]
if u.isMasterTask():
return frozen_coords
else:
return None
def init():
# Units. 1 == Mirheo unit.
nm = 1
fs = 1
kg = 1e27
K = 1
m = 1e9
s = 1e15
J = kg * m**2 / s**2
# Argon model and system properties.
epsilon = 996. * J / 6.022e23
sigma = 0.340 * nm
mass = 39.948 * 1.66053906660e-27 * kg
number_density = 0.6 / sigma**3
domain = (10 * nm, 8 * nm, 6 * nm)
u = mir.Mirheo((1, 1, 1),
domain,
dt=1.0 * fs,
debug_level=3,
log_filename='log',
no_splash=True,
units=mir.UnitConversion(1 / m, 1 / s, 1 / kg))
pv = mir.ParticleVectors.ParticleVector('pv', mass=mass)
ic = mir.InitialConditions.Uniform(number_density=number_density)
u.registerParticleVector(pv, ic)
# With the ordinary LJ the simulation would immediately blow up.
# lj = mir.Interactions.Pairwise('lj', rc=1 * nm, kind='LJ', epsilon=epsilon, sigma=sigma)
lj = mir.Interactions.Pairwise('lj',
rc=1 * nm,
kind='RepulsiveLJ',
epsilon=epsilon,
sigma=sigma,
max_force=1e-4)
u.registerInteraction(lj)
u.setInteraction(lj, pv, pv)
vv = mir.Integrators.VelocityVerlet('vv')
u.registerIntegrator(vv)
u.setIntegrator(vv, pv)
u.registerPlugins(
mir.Plugins.createBerendsenThermostat('thermostat', [pv],
T=215 * K,
tau=50.0 * fs))
u.registerPlugins(mir.Plugins.createStats('stats', every=50))
u.run(0)
u.saveSnapshot('snapshot')
def create_from_mesh(density, vertices, triangles, inertia, niter):
import mirheo as mir
def recenter(coords, com):
coords = [[r[0]-com[0], r[1]-com[1], r[2]-com[2]] for r in coords]
return coords
dt = 0.001
# bounding box
bb_hi = np.array(vertices).max(axis=0).tolist()
bb_lo = np.array(vertices).min(axis=0).tolist()
mesh_size = [hi-lo for lo, hi in zip(bb_lo, bb_hi)]
fact = 2.0
domain = (float (int (fact * mesh_size[0] + 1) ),
float (int (fact * mesh_size[1] + 1) ),
float (int (fact * mesh_size[2] + 1) ))
ranks = (1, 1, 1)
u = mir.Mirheo(ranks, domain, debug_level=3, log_filename='log', no_splash=True)
dpd = mir.Interactions.Pairwise('dpd', rc=1.0, kind="DPD", a=10.0, gamma=10.0, kBT=0.5, power=0.5)
vv = mir.Integrators.VelocityVerlet('vv')
coords = [bb_lo, bb_hi]
com_q = [[0.5 * domain[0], 0.5 * domain[1], 0.5 * domain[2], 1., 0, 0, 0]]
mesh = mir.ParticleVectors.Mesh(vertices, triangles)
fake_ov = mir.ParticleVectors.RigidObjectVector('OV', mass=1, inertia=inertia, object_size=len(coords), mesh=mesh)
fake_ic = mir.InitialConditions.Rigid(com_q=com_q, coords=coords)
belonging_checker = mir.BelongingCheckers.Mesh("meshChecker")
pvMesh = u.makeFrozenRigidParticles(belonging_checker, fake_ov, fake_ic, [dpd], vv, density, 1.0, dt=dt, nsteps=niter)
if pvMesh:
frozen_coords = pvMesh.getCoordinates()
frozen_coords = recenter(frozen_coords, com_q[0])
else:
frozen_coords = [[]]
if u.isMasterTask():
return frozen_coords
else:
return None
def run(args):
"""The `mirheo run` command.
Usage:
run [--ranks NX NY NZ]
[--num-timesteps NUM]
[--final-snapshot PATH]
snapshot_path
"""
u = mirheo.Mirheo(args.ranks, snapshot=args.snapshot, debug_level=3, log_filename='log')
u.run(args.num_timesteps)
if args.final_snapshot:
u.saveSnapshot(args.final_snapshot)
#!/usr/bin/env python
import mirheo as mir
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--ranks', type=int, nargs=3, required=True)
parser.add_argument('--save-to', type=str, required=True)
parser.add_argument('--load-from', type=str)
args = parser.parse_args()
if not args.load_from:
u = mir.Mirheo(args.ranks,
domain=(4, 6, 8),
dt=0.1,
debug_level=3,
log_filename='log',
no_splash=True)
mesh = mir.ParticleVectors.MembraneMesh('mesh_dummy1.off')
ov = mir.ParticleVectors.MembraneVector('ov', mesh=mesh, mass=1)
pv = ov
ic = mir.InitialConditions.Membrane([])
u.registerParticleVector(ov, ic)
wall = mir.Walls.Plane('plane', (0, -1, 0), (1.0, 2.0, 3.0))
u.registerWall(wall, check_every=123)
u.registerPlugins(
mir.Plugins.createStats('stats', every=10, filename='stats'))
u.registerPlugins(
parser = argparse.ArgumentParser()
parser.add_argument('--vis', action='store_true', default=False)
parser.add_argument('--restart', action='store_true', default=False)
parser.add_argument("--ranks", type=int, nargs=3, default=[1, 1, 1])
args = parser.parse_args()
dt = 0.001
t_end = 2.5 + dt # time for one restart batch
ranks = args.ranks
domain = (8, 8, 8)
u = mir.Mirheo(ranks,
domain,
dt,
debug_level=3,
log_filename='log',
checkpoint_every=int(0.5 / dt),
no_splash=True)
nparts = 1000
np.random.seed(42)
pos = np.random.normal(loc=[0.5, 0.5 * domain[1] + 1.0, 0.5 * domain[2]],
scale=[0.1, 0.3, 0.3],
size=(nparts, 3))
vel = np.random.normal(loc=[1.0, 0., 0.],
scale=[0.1, 0.01, 0.01],
size=(nparts, 3))
pvSolvent = mir.ParticleVectors.ParticleVector('pv', mass=1)
def main():
# Units. 1 == Mirheo unit.
nm = 1
fs = 1
kg = 1e27
K = 1
m = 1e9 * nm
s = 1e15 * fs
J = kg * m**2 / s**2
# Argon and system properties.
epsilon = 996. * J / 6.022e23
sigma = 0.340 * nm
mass = 39.948 * 1.66053906660e-27 * kg
kB = 1.380649e-23 * J / K
max_displacement = 0.005 * nm
number_density = 0.1 / sigma**3 # Use very small density for testing.
domain = (12 * nm, 10 * nm, 8 * nm)
u = mir.Mirheo((1, 1, 1),
domain,
debug_level=3,
log_filename='log',
no_splash=True)
pv = mir.ParticleVectors.ParticleVector('pv', mass=mass)
ic = mir.InitialConditions.Uniform(number_density=number_density)
u.registerParticleVector(pv, ic)
lj = mir.Interactions.Pairwise('lj',
rc=1 * nm,
kind='LJ',
epsilon=epsilon,
sigma=sigma)
u.registerInteraction(lj)
u.setInteraction(lj, pv, pv)
##############################
# Stage 1.
##############################
int_min = mir.Integrators.Minimize('minimize',
max_displacement=max_displacement)
u.registerIntegrator(int_min)
u.setIntegrator(int_min, pv)
# Measure forces, they should decrease over time.
plugin_force_saver = mir.Plugins.createForceSaver('forceSaver', pv)
plugin_dump = mir.Plugins.createDumpParticles('meshdump', pv, 200,
['forces'], 'h5/pv-')
u.registerPlugins(plugin_force_saver)
u.registerPlugins(plugin_dump)
u.run(1001, dt=0.01 * fs)
u.deregisterPlugins(plugin_dump)
u.deregisterPlugins(plugin_force_saver)
u.deregisterIntegrator(int_min)
del plugin_dump
del plugin_force_saver
##############################
# Stage 2.
##############################
int_vv = mir.Integrators.VelocityVerlet('vv')
u.registerIntegrator(int_vv)
u.setIntegrator(int_vv, pv)
# Measure temperature, it should approach the reference temperature.
u.registerPlugins(
mir.Plugins.createBerendsenThermostat('thermostat', [pv],
kBT=215 * K * kB,
tau=50.0 * fs))
u.registerPlugins(
mir.Plugins.createStats('stats', every=50, filename='stats.csv'))
u.run(500, dt=1 * fs)
##############################
# Stage 3.
##############################
u.run(200, dt=5 * fs)
if MPI.COMM_WORLD.rank == 0:
print("log(force) during minimization", file=sys.stderr)
for i in range(5):
forces = get_h5_forces('h5/pv-{:05}.h5'.format(i))
forces = np.sqrt(forces[:, 0]**2 + forces[:, 1]**2 +
forces[:, 2]**2)
forces = np.sum(forces)
# Using log because nTEST has a tolerance of 0.1.
print(i, np.log(forces + 1e-9) * 100, file=sys.stderr)
# This could be done with pandas, but better to avoid importing it.
print("temperature during equilibration and the run", file=sys.stderr)
with open('stats.csv', 'r') as f:
header = f.readline().split(',')
assert header[0:2] == ['time', 'kBT']
mat = np.loadtxt(f, delimiter=',', usecols=(0, 1))
mat[:, 1] /= kB
for row in mat:
print(*row, file=sys.stderr)
#!/usr/bin/env python
import mirheo as mir
dt = 0.001
ranks = (1, 1, 1)
domain = (12, 8, 10)
rc = 1.0
density = 8
u = mir.Mirheo(ranks, domain, no_splash=True, debug_level=0, log_filename='stdout')
pv = mir.ParticleVectors.ParticleVector('pv', mass = 1)
ic = mir.InitialConditions.Uniform(density)
u.registerParticleVector(pv, ic)
dpd = mir.Interactions.Pairwise('dpd', rc, kind="DPD", a=10.0, gamma=10.0, kBT=1.0, power=0.5)
u.registerInteraction(dpd)
u.setInteraction(dpd, pv, pv)
vv = mir.Integrators.VelocityVerlet('vv')
u.registerIntegrator(vv)
u.setIntegrator(vv, pv)
u.run(50, dt=dt)
# TEST: log.silent
# cd log
# mir.run --runargs "-n 2" ./silent.py > log.out.txt
parser = argparse.ArgumentParser()
parser.add_argument("--restart", action='store_true', default=False)
parser.add_argument("--ranks", type=int, nargs=3)
args = parser.parse_args()
ranks = args.ranks
domain = (4, 6, 8)
dt = 0
comm = MPI.COMM_WORLD
u = mir.Mirheo(ranks,
domain,
comm_ptr=MPI._addressof(comm),
debug_level=3,
log_filename='log',
no_splash=True,
checkpoint_every=(0 if args.restart else 5))
pv = mir.ParticleVectors.ParticleVector('pv', mass=1)
if args.restart:
ic = mir.InitialConditions.Restart("restart/")
else:
ic = mir.InitialConditions.Uniform(number_density=2)
u.registerParticleVector(pv, ic)
u.run(7, dt=dt)
sys.exit()
ureg = pint.UnitRegistry()
ureg.define('myL = 0.5 um')
ureg.define('myT = 0.25 us')
ureg.define('myM = 0.125 ug')
# Set global unit registry for all Mirheo functions.
mir.set_unit_registry(ureg, 'myL', 'myT', 'myM')
# Test the unit conversion (not all arguments are probably dimensionalized below).
domain = (10 * ureg.um, 15 * ureg.um, 20 * ureg.um)
dt = 123 * ureg.us
u = mir.Mirheo((1, 1, 1),
domain,
dt,
debug_level=3,
log_filename='log',
no_splash=True)
pv = mir.ParticleVectors.ParticleVector('pv', mass=1e-9 * ureg.kg)
ic = mir.InitialConditions.Uniform(number_density=2 * ureg.um**-3)
u.registerParticleVector(pv, ic)
kBT = ureg('1.125 um**2 * ug / us**2')
dpd = mir.Interactions.Pairwise('dpd',
rc=1.0 * ureg.um,
kind='DPD',
a=10.0,
gamma=10.0,
kBT=kBT,
power=0.5)
#!/usr/bin/env python
"""Test checkpoint-like periodic snapshots.
We test that there are that many folders and that the currentStep changes.
"""
import mirheo as mir
u = mir.Mirheo(nranks=(1, 1, 1), domain=(4, 6, 8), dt=0.125, debug_level=3,
log_filename='log', no_splash=True,
checkpoint_every=10, checkpoint_mode='Incremental',
checkpoint_folder='periodic_snapshots/snapshot_', checkpoint_mechanism='Snapshot')
pv = mir.ParticleVectors.ParticleVector('pv', mass=1)
ic = mir.InitialConditions.Uniform(number_density=2)
u.registerParticleVector(pv, ic)
dpd = mir.Interactions.Pairwise('dpd', rc=1.0, kind='DPD', a=10.0, gamma=10.0, kBT=1.0, power=0.5)
lj = mir.Interactions.Pairwise('lj', rc=1.0, kind='LJ', epsilon=1.25, sigma=0.75)
u.registerInteraction(dpd)
u.registerInteraction(lj)
u.setInteraction(dpd, pv, pv)
minimize = mir.Integrators.Minimize('minimize', max_displacement=1. / 1024)
u.registerIntegrator(minimize)
u.run(45)
# TEST: snapshot.periodic
# cd snapshot
parser.add_argument('--axes', type=float, nargs=3)
parser.add_argument('--coords', type=str)
parser.add_argument("--restart", action='store_true', default=False)
parser.add_argument("--ranks", type=int, nargs=3, default=(1,1,1))
args = parser.parse_args()
dt = 0.001
axes = tuple(args.axes)
a = 0.5
density = args.density
domain = (16, 8, 8)
nsteps = 5000
u = mir.Mirheo(args.ranks, domain, debug_level=3, log_filename='log', no_splash=True,
checkpoint_every = (0 if args.restart else nsteps))
pv_sol = mir.ParticleVectors.ParticleVector('solvent', mass = 1)
ic_sol = mir.InitialConditions.Uniform(density)
dpd = mir.Interactions.Pairwise('dpd', rc=1.0, kind="DPD", a=10.0, gamma=10.0, kBT=0.01, power=0.5)
cnt = mir.Interactions.Pairwise('cnt', rc=1.0, kind="RepulsiveLJ", epsilon=0.28, sigma=0.8, max_force=400.0)
vv = mir.Integrators.VelocityVerlet_withPeriodicForce('vv', force=a, direction="x")
com_q = [[2.0, 5.0, 5.0, 1.0, np.pi/2, np.pi/3, 0.0],
[4.0, 4.0, 5.0, 1.0, np.pi/2, np.pi/3, 0.0],
[6.0, 3.0, 5.0, 1.0, np.pi/2, np.pi/3, 0.0]]
coords = np.loadtxt(args.coords).tolist()
pv_ell = mir.ParticleVectors.RigidEllipsoidVector('ellipsoid', mass=1, object_size=len(coords), semi_axes=axes)
ic_ell = mir.InitialConditions.Rigid(com_q=com_q, coords=coords)
parser.add_argument("--ranks", type=int, nargs=3)
args = parser.parse_args()
ranks = args.ranks
domain = (4, 6, 8)
dt = 0
if args.restart:
restart_folder = "restart2/"
else:
restart_folder = "restart/"
u = mir.Mirheo(ranks,
domain,
dt,
debug_level=3,
log_filename='log',
checkpoint_every=5,
checkpoint_folder=restart_folder,
no_splash=True)
pv = mir.ParticleVectors.ParticleVector('pv', mass=1)
ic = mir.InitialConditions.Uniform(number_density=2)
u.registerParticleVector(pv, ic)
dpd = mir.Interactions.Pairwise('dpd',
rc=1.0,
kind="DPD",
a=10.0,
gamma=10.0,
kBT=1.0,
power=0.5)
#!/usr/bin/env python
import mirheo as mir
dt = 0.001
ranks = (1, 1, 1)
domain = (8, 8, 8)
u = mir.Mirheo(ranks, domain, debug_level=3, log_filename='log')
pv = mir.ParticleVectors.ParticleVector('pv', mass=1)
ic = mir.InitialConditions.Uniform(number_density=10)
u.registerParticleVector(pv, ic)
dpd = mir.Interactions.Pairwise('dpd',
rc=1.0,
kind="DPD",
a=10.0,
gamma=10.0,
kBT=1.0,
power=0.5)
u.registerInteraction(dpd)
u.setInteraction(dpd, pv, pv)
vv = mir.Integrators.VelocityVerlet('vv')
u.registerIntegrator(vv)
u.setIntegrator(vv, pv)
u.registerPlugins(mir.Plugins.createStats('stats', "stats", 200))
#!/usr/bin/env python
import mirheo as mir
import numpy as np
density = 4
ranks = (1, 1, 1)
axes = (1.0, 2.0, 3.0)
fact = 3
domain = (fact * axes[0], fact * axes[1], fact * axes[2])
u = mir.Mirheo(ranks,
domain,
dt=0,
debug_level=3,
log_filename='log',
no_splash=True)
coords = [[-axes[0], -axes[1], -axes[2]], [axes[0], axes[1], axes[2]]]
com_q = [[0.5 * domain[0], 0.5 * domain[1], 0.5 * domain[2], 1., 0, 0, 0]]
pv_ell = mir.ParticleVectors.RigidEllipsoidVector('ellipsoid',
mass=1,
object_size=len(coords),
semi_axes=axes)
ic_ell = mir.InitialConditions.Rigid(com_q, coords)
u.registerParticleVector(pv_ell, ic_ell)
pv_outer = mir.ParticleVectors.ParticleVector('pv_outer', mass=1.0)
ic_outer = mir.InitialConditions.Uniform(density)
def run_one_force(comm_address, force, x0, ks):
import mirheo as mir
import trimesh
toolsPath = os.path.join(this_dir, "tools")
#print(toolsPath)
sys.path.append(toolsPath)
import stretchForce as stretch
import diameters
from rbc_params import set_rbc_params
from rbc_params import print_rbc_params
def original_diameter(mesh):
pos = np.array(mesh.vertices, copy=True)
(D0, D1) = diameters.computeDiameters(pos)
return 0.5 * (D0 + D1)
tend = 50.0
dt = 0.001
mesh = trimesh.load_mesh(mesh_fname)
safety = 3
box_lo = np.amin(mesh.vertices, axis=0)
box_hi = np.amax(mesh.vertices, axis=0)
domain = (box_hi - box_lo) * safety + np.ones(3)
domain = tuple(np.array(domain, dtype=int))
ranks = (1, 1, 1)
u = mir.Mirheo(ranks,
domain,
dt,
debug_level=0,
log_filename='stderr',
comm_ptr=comm_address,
no_splash=True)
mesh_rbc = mir.ParticleVectors.MembraneMesh(mesh.vertices.tolist(),
mesh.faces.tolist())
pv_rbc = mir.ParticleVectors.MembraneVector("rbc", mass=1.0, mesh=mesh_rbc)
ic_rbc = mir.InitialConditions.Membrane([[
domain[0] * 0.5, domain[1] * 0.5, domain[2] * 0.5, 1.0, 0.0, 0.0, 0.0
]])
u.registerParticleVector(pv_rbc, ic_rbc)
# mu_ph = 2.5 # [micro N / m]
force_scale = 0.025 # [pN]
force = force / force_scale
D0 = original_diameter(mesh)
D0_ph = 7.739 # [micro m]
prms_rbc = set_rbc_params(mesh, x0, ks)
prms_rbc["gammaT"] = 1.0 # for killing oscillations
int_rbc = mir.Interactions.MembraneForces("int_rbc",
**prms_rbc,
stress_free=True)
vv = mir.Integrators.VelocityVerlet('vv')
u.registerIntegrator(vv)
u.setIntegrator(vv, pv_rbc)
u.registerInteraction(int_rbc)
u.setInteraction(int_rbc, pv_rbc, pv_rbc)
fraction = 0.05 * 2
n = int(len(mesh.vertices) * fraction)
force = force / (0.5 * n)
forces = stretch.computeForces(mesh.vertices, fraction, force).tolist()
u.registerPlugins(
mir.Plugins.createMembraneExtraForce("stretchForce", pv_rbc, forces))
u.registerPlugins(mir.Plugins.createStats('stats', "stats.txt", 1000))
u.run(int(tend / dt))
Dshort = 0
Dlong = 0
if u.isMasterTask():
rbc_pos = pv_rbc.getCoordinates()
(Dlong, Dshort) = diameters.computeDiameters(rbc_pos)
# make it dimensional again
Dlong = (Dlong / D0) * D0_ph
Dshort = (Dshort / D0) * D0_ph
del u
del vv
del int_rbc
del prms_rbc
del mesh_rbc
del pv_rbc
del ic_rbc
return Dshort, Dlong
#!/usr/bin/env python
import mirheo as mir
ranks = (1, 1, 1)
domain = [4.0, 5.0, 6.0]
dt = 100.0 # large dt to force the particles to go too far
u = mir.Mirheo(ranks, tuple(domain), dt, debug_level=3, log_filename='log', no_splash=True)
pv = mir.ParticleVectors.ParticleVector('pv', mass = 1)
pos = [[a*domain[0], a*domain[1], a*domain[2]] for a in [0.1, 0.5, 0.8]]
v=[1., 2., 3.]
vel = [[a*v[0], a*v[1], a*v[2]] for a in [0.0, 0.0, 1.0]] # only one particle will go out of bounds
ic = mir.InitialConditions.FromArray(pos, vel)
u.registerParticleVector(pv, ic)
vv = mir.Integrators.VelocityVerlet('vv')
u.registerIntegrator(vv)
u.setIntegrator(vv, pv)
check_every = 1
u.registerPlugins(mir.Plugins.createParticleChecker('checker', check_every))
u.run(2)
# TEST: plugins.particle_check.bounds
def run(comm_address,
gammaC,
NDATA,
TEND,
kT_s,
T_p,
etao_p,
etai_p,
mu_p,
Ka_p,
kb_p,
area_p,
volume_p,
verbose,
dryrun,
ini_mesh_fname,
ref_mesh_fname,
ply_dir='ply/'):
import trimesh
import numpy as np
from pint import UnitRegistry
import mirheo as mir
import dpdParams as D
import rbcParams as R
logfile = open(ply_dir + "config.txt", "a")
ureg = UnitRegistry()
def effective_radius_from_area(A):
return np.sqrt(A / (4.0 * np.pi))
@ureg.wraps(None, ureg.dimensionless)
def to_sim(a):
return a
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Physical values (_p), in SI units
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A_p = area_p * ureg.m**2
V_p = volume_p * ureg.m**3
R_p = effective_radius_from_area(A_p)
mu_p = mu_p * ureg.N / ureg.m
Ka_p = Ka_p * ureg.N / ureg.m
kb_p = kb_p * ureg.J
kB_p = constants.get('kBoltz') * ureg.J / ureg.K
T_p = T_p * ureg.K
kT_p = kB_p * T_p
Gka_p = constants.get('Gka') * ureg.J / ureg.m**2
Gkv_p = constants.get('Gkv') * ureg.J / ureg.m**3
a3 = constants.get('a3')
a4 = constants.get('a4')
b1 = constants.get('b1')
b2 = constants.get('b2')
rho_p = constants.get('rho') * ureg.kg / ureg.m**3
etai_p = etai_p * ureg.Pa * ureg.s
etao_p = etao_p * ureg.Pa * ureg.s
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Non-dimensional numbers:
#
# FvK_p : Foeppl-von-Karman number in healthy cells
# fKa_p : Ka / mu
# lm_p : ratio between inner and outer viscosity
# FGKa_p : dimensionless area constraint coefficient
# FGKv_p : dimensionless volume constraint coefficient
# Ftherm : ratio between bending modulus and thermal energy
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
FvK_p = mu_p * R_p * R_p / kb_p
fKa_p = Ka_p / mu_p
FGKa_p = Gka_p * R_p**2 / kb_p
FGKv_p = Gkv_p * R_p**3 / kb_p
Ftherm = kb_p / kT_p
lm_p = etai_p / etao_p
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Simulation (_s)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Simulation length of rbc
suggested_radius = constants.get('R0')
# Scale initial mesh to suggested radius
ini = trimesh.load(ini_mesh_fname, process=False)
ref = trimesh.load(ref_mesh_fname, process=False)
original_radius = effective_radius_from_area(ini.area)
rbc_scaling = suggested_radius / original_radius
ini.vertices *= rbc_scaling
ref.vertices *= rbc_scaling
# set length scale (R_s)
Nv = len(ini.vertices)
Nv_ref = len(ref.vertices)
A_s = ini.area
V_s = ini.volume
R_s = suggested_radius
# set mass scale (mass_s)
nd = constants.get('nd')
mass_s = constants.get('mass')
rho_s = mass_s * nd
# rbc mass, assume membrane is 2D surface
M_s = rho_s * A_s
mmass_s = M_s / Nv
# set time scale (based on kBT)
kT_s = kT_s
# unit scalings
L_UNIT = R_p / R_s
M_UNIT = rho_p / rho_s * (L_UNIT**3)
T_UNIT = np.sqrt(kT_s / kT_p * L_UNIT**2 * M_UNIT)
F_UNIT = M_UNIT * L_UNIT / T_UNIT**2
E_UNIT = F_UNIT * L_UNIT
VISC_UNIT = F_UNIT / L_UNIT**2 * T_UNIT
# Numerical parameters
AIJ = constants.get('AIJ')
rc = constants.get('rc')
rho0_s = constants.get('rho0')
aij = AIJ * kT_s / rc
cs_s = D.get_Cs_(aij, nd, mass_s, kT_s)
kpow = constants.get('kpow')
kb_s = to_sim(Ftherm * kT_s)
mu_s = to_sim(FvK_p * kb_s / (R_s**2))
Ka_s = to_sim(fKa_p * mu_s)
kade_s = 0. # use Minimum rbc model
DA0D_s = 0.
C0_s = 0.
Gka_s = to_sim(FGKa_p * kb_s / (R_s**2))
Gkv_s = to_sim(FGKv_p * kb_s / (R_s**3))
kT_rbc = kT_s
etao_s = to_sim(etao_p / VISC_UNIT)
etai_s = to_sim(lm_p * etao_s)
nuo_s = etao_s / rho_s
nui_s = etai_s / rho_s
gij = D.get_gij(aij, nuo_s * rho0_s)
gin = D.get_gij(aij, nui_s * rho0_s)
gfsi_o = R.get_gammafsiDPD(nuo_s * rho0_s, kpow, A_s, Nv, nd, rc)
gfsi_i = R.get_gammafsiDPD(nui_s * rho0_s, kpow, A_s, Nv, nd, rc)
gT = 0.
gC = gammaC
etam_s = np.sqrt(3) / 4. * gC # approximation, Fedosov2010
FvK_s = mu_s * R_s**2 / kb_s
Ftherm_s = kb_s / kT_s
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Timestep estimation
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~ Solvent timestep:
# computed based on the timesteps
# from sonic, viscous and acceleration
# constraints as defined in Morris1997
LX_min = min(ini.vertices[:, 0])
LX_max = max(ini.vertices[:, 0])
DX = LX_max - LX_min
LX_min = min(ref.vertices[:, 0])
LX_max = max(ref.vertices[:, 0])
DX0 = LX_max - LX_min
vcell_s = 0.5 * (DX - DX0) / to_sim(0.2 * ureg.s / T_UNIT)
h = D.interparticle_distance(nd)
Cdt = constants.get('Cdt')
Cdt_visc = constants.get('Cdt_visc')
dtmax = constants.get('dtmax')
dt_sonic = D.get_dt_sonic(h, cs_s, C=Cdt)
dt_visc = D.get_dt_viscous(h, max([etao_s, etai_s]), rho_s, C=Cdt_visc)
Fdpd = D.get_total_dpd_force(nd, rc, aij, max([gfsi_o, gfsi_i, gij, gin]),
vcell_s, kT_s, min([dt_sonic, dt_visc]))
dt_acc = D.get_dt_accel_(h, Fdpd, mass_s, C=Cdt)
dt_fluid = min([dtmax, dt_sonic, dt_visc, dt_acc])
dt = dt_fluid
# ~ Membrane substeps:
# Computed based on the timesteps
# from viscous and acceleration
# constraints as defined in Morris1997
hm = R.intervertex_distance(A_s, Nv)
Fdpd = D.get_total_dpd_force(nd, rc, aij, max([gfsi_o, gfsi_i]), vcell_s,
kT_s, dt_fluid)
Fintern = (mu_s + Ka_s) * hm + (kb_s +
kade_s) / hm + Gka_s * hm + Gkv_s * hm**2
dt_m_acc = D.get_dt_accel_(hm, Fdpd + Fintern, mmass_s, C=Cdt)
dt_m_visc = D.get_dt_viscous(hm,
max([etao_s, etai_s, etam_s / hm]),
rho_s,
C=Cdt_visc)
dt_rbc = min([dt_m_visc, dt_m_acc])
substeps = min(int(dt_fluid / dt_rbc + 0.5), 100)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Checking/Dumping frequencies
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
tend_p = TEND * ureg.s
Ndumps = NDATA
tdump_s = to_sim(tend_p / (Ndumps - 1) / T_UNIT)
dumpfreq = int(tdump_s / dt + 0.5)
tdump_s = dumpfreq * dt
iend = (Ndumps - 1) * dumpfreq + 1
correctfreq = constants.get('correctfreq')
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Domain, ranks
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
safety = constants.get('safety')
LX_min = min(ini.vertices[:, 0])
LX_max = max(ini.vertices[:, 0])
LX = int(safety * (LX_max - LX_min) + 0.5)
LY_min = min(ref.vertices[:, 1])
LY_max = max(ref.vertices[:, 1])
LY = int(safety * (LY_max - LY_min) + 0.5)
LZ_min = min(ini.vertices[:, 2])
LZ_max = max(ini.vertices[:, 2])
LZ = int(safety * (LZ_max - LZ_min) + 0.5)
LX = LX + np.mod(LX, 2)
LY = LY + np.mod(LY, 2)
LZ = LZ + np.mod(LZ, 2)
domain = (LX, LY, LZ)
ranks = (1, 1, 1)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Group parameters
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
sim = {
"domain": domain,
"dumpfreq": dumpfreq,
"correctfreq": correctfreq,
"substeps": substeps,
"iend": iend,
"gfsi_o": gfsi_o,
"gfsi_i": gfsi_i,
}
plasma = D.set_dpd_params(aij, gij, kT_s, kpow, rc, nd, mass_s)
hemogl = D.set_dpd_params(aij, gin, kT_s, kpow, rc, nd, mass_s)
rbc = R.set_rbc_params_ade_lwm(Gka_s, Gkv_s, A_s, V_s, gT, gC, kT_rbc,
Ka_s, a3, a4, mu_s, b1, b2, kb_s, C0_s,
kade_s, DA0D_s)
mesh = R.set_mesh_params(ini, ref, Nv, mmass_s)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Start simulation
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# chech debug_level (DW)
u = mir.Mirheo(ranks,
domain,
dt,
debug_level=3,
log_filename=ply_dir + 'log',
comm_ptr=comm_address,
no_splash=True)
if u.isComputeTask() and verbose:
logfile.write("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
logfile.write("\n~~~ Physical Units ~~~")
logfile.write("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
logfile.write("\n>> Non-dimensional quantities:")
logfile.write("\nFvK :" + str(FvK_p))
logfile.write("\nfKa :" + str(fKa_p))
logfile.write("\nFGKa_p :" + str(FGKa_p))
logfile.write("\nFGKv_p :" + str(FGKv_p))
logfile.write("\nFtherm :" + str(Ftherm))
logfile.write("\n>> Dimensional quantities:")
logfile.write("\nmu_p:" + str(mu_p))
logfile.write("\nKa_p:" + str(Ka_p))
logfile.write("\nA_p:" + str(A_p))
logfile.write("\netao_p:" + str(etao_p))
logfile.write("\netai_p:" + str(etai_p))
logfile.write("\nRe_p:" +
str(vcell_s * L_UNIT / T_UNIT * R_p * rho_p / etao_p))
logfile.write("\nMa_p:" + str(vcell_s * L_UNIT / T_UNIT /
(1500. * ureg.m / ureg.s)))
logfile.write("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
logfile.write("\n~~~ Simulation Units ~~~")
logfile.write("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
logfile.write("\n>> Non-dimensional quantities:")
logfile.write("\nFvK :" + str(FvK_s))
logfile.write("\nFtherm:" + str(Ftherm_s))
logfile.write("\n>> Dimensional quantities:")
logfile.write("\nR_s:" + str(R_s))
logfile.write("\nA_s:" + str(A_s))
logfile.write("\nV_s:" + str(V_s))
logfile.write("\nkT_s:" + str(kT_s))
logfile.write("\nmu_s:" + str(mu_s))
logfile.write("\nKa_s:" + str(Ka_s))
logfile.write("\nkb_s:" + str(kb_s))
logfile.write("\nGkv_s:" + str(Gkv_s))
logfile.write("\nGka_s:" + str(Gka_s))
logfile.write("\naij:" + str(aij))
logfile.write("\ngij:" + str(gij))
logfile.write("\ngin:" + str(gin))
logfile.write("\ngC:" + str(gC))
logfile.write("\ngT:" + str(gT))
logfile.write("\netao_s:" + str(etao_s))
logfile.write("\netai_s:" + str(etai_s))
logfile.write("\netam_s:" + str(etam_s))
logfile.write("\nmmass_s:" + str(mmass_s))
logfile.write("\nvcell_s:" + str(vcell_s))
logfile.write("\nNdumps:" + str(Ndumps))
logfile.write("\ntend:" + str(TEND))
logfile.write("\ndt:" + str(dt))
logfile.write("\ndt_visc:" + str(dt_visc))
logfile.write("\ndt_acc:" + str(dt_acc))
logfile.write("\ndt_m_visc:" + str(dt_m_visc))
logfile.write("\ndt_m_acc:" + str(dt_m_acc))
logfile.write("\nsubsteps:" + str(substeps))
logfile.write("\ndumpfreq:" + str(dumpfreq))
logfile.write("\ndumptime:" + str(tdump_s))
logfile.write("\niend:" + str(iend))
logfile.write("\ndomain:" + str(domain))
logfile.write("\nRe_s:" + str(vcell_s * R_s * rho_s / etao_s))
logfile.write("\nMa_s:" + str(vcell_s / cs_s))
logfile.write("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
logfile.write("\n~~~ Unit Transforms ~~~")
logfile.write("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
logfile.write("\nL_UNIT:" + str(L_UNIT.to_base_units()))
logfile.write("\nT_UNIT:" + str(T_UNIT.to_base_units()))
logfile.write("\nM_UNIT:" + str(M_UNIT.to_base_units()))
logfile.write("\nChecks:")
logfile.write("\nR_s/R_p: " + str((R_s * L_UNIT / R_p)))
logfile.write("\nkT_s/kT_p: " + str((kT_s * E_UNIT / kT_p)))
logfile.write("\nkb_s/kb_p: " + str((kb_s * E_UNIT / kb_p)))
logfile.write("\netao_s/etao_p: " + str((etao_s * VISC_UNIT / etao_p)))
logfile.close()
if not dryrun:
simulation(u, plasma, hemogl, rbc, mesh, sim, ply_dir)
del u
del plasma
del hemogl
del rbc
del mesh
del sim
