Python ymero.ymero函数代码示例

def createEllipsoid(density, axes, niter):
    import ymero as ymr
    
    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 = ymr.ymero(ranks, domain, dt, debug_level=3, log_filename='log')
    
    dpd = ymr.Interactions.DPD('dpd', 1.0, a=10.0, gamma=10.0, kbt=0.5, power=0.5)
    vv = ymr.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]]
    
    fakeOV = ymr.ParticleVectors.RigidEllipsoidVector('OV', mass=1, object_size=len(coords), semi_axes=axes)
    fakeIc = ymr.InitialConditions.Rigid(com_q=com_q, coords=coords)
    belongingChecker = ymr.BelongingCheckers.Ellipsoid("ellipsoidChecker")
    
    pvEllipsoid = u.makeFrozenRigidParticles(belongingChecker, fakeOV, fakeIc, [dpd], vv, density, niter)
    
    if pvEllipsoid:
        frozenCoords = pvEllipsoid.getCoordinates()
        frozenCoords = recenter(frozenCoords, com_q[0])
    else:
        frozenCoords = [[]]

    if u.isMasterTask():
        return frozenCoords
    else:
        return None

def run(niter, statsFname, comm_address):
    dt = 0.001

    ranks  = (2, 1, 1)
    domain = (12, 8, 10)
    
    u = ymr.ymero(ranks, domain, dt, debug_level=8, log_filename='log', comm_ptr=comm_address)
    
    pv = ymr.ParticleVectors.ParticleVector('pv', mass = 1)
    ic = ymr.InitialConditions.Uniform(density=2)
    u.registerParticleVector(pv=pv, ic=ic)

    dpd = ymr.Interactions.DPD('dpd', 1.0, a=10.0, gamma=10.0, kbt=1.0, power=0.5)
    u.registerInteraction(dpd)
    u.setInteraction(dpd, pv, pv)
    
    vv = ymr.Integrators.VelocityVerlet('vv')
    u.registerIntegrator(vv)
    u.setIntegrator(vv, pv)
    
    stats = ymr.Plugins.createStats('stats', statsFname, 1000)
    u.registerPlugins(stats)
    
    u.run(niter)

parser = argparse.ArgumentParser()
parser.add_argument('--subStep', action='store_true', default=False)
parser.add_argument('--vis', action='store_true', default=False)
args = parser.parse_args()

dt = 0.001

substeps = 10
if args.subStep:
    dt = dt * substeps

ranks  = (1, 1, 1)
domain = (8, 8, 8)

u = ymr.ymero(ranks, domain, dt, debug_level=3, log_filename='log')

nparts = 1000
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 = ymr.ParticleVectors.ParticleVector('pv', mass = 1)
icSolvent = ymr.InitialConditions.FromArray(pos=pos.tolist(), vel=vel.tolist())
vv        = ymr.Integrators.VelocityVerlet('vv')
u.registerParticleVector(pvSolvent, icSolvent)

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

if args.restart:
    restart_folder="restart2/"
else:
    restart_folder="restart/"

u = ymr.ymero(ranks, domain, dt, debug_level=3, log_filename='log', checkpoint_every=5, checkpoint_folder=restart_folder)
    
pv = ymr.ParticleVectors.ParticleVector('pv', mass = 1)
ic = ymr.InitialConditions.Uniform(density=2)
u.registerParticleVector(pv, ic)

dpd = ymr.Interactions.DPD('dpd', 1.0, a=10.0, gamma=10.0, kbt=1.0, power=0.5)
u.registerInteraction(dpd)
u.setInteraction(dpd, pv, pv)

if args.restart:
    u.restart("restart/")
u.run(7)
    

# TEST: restart.interactions

#!/usr/bin/env python

import ymero as ymr
import numpy as np
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--ranks', type=int, nargs=3, required=True)
args = parser.parse_args()

domain = (8, 16, 4)

u = ymr.ymero(args.ranks, domain, dt=0, debug_level=8, log_filename='log')

pv = ymr.ParticleVectors.ParticleVector('pv', mass = 1)
ic = ymr.InitialConditions.Uniform(density=3)
u.registerParticleVector(pv=pv, ic=ic)

sampleEvery = 1
dumpEvery   = 1
binSize     = (1., 1., 1.)

field = ymr.Plugins.createDumpAverage('field', [pv], sampleEvery, dumpEvery, binSize, [("velocity", "vector_from_float8")], 'h5/solvent-')
u.registerPlugins(field)

u.run(3)

# TEST: dump.h5
# cd dump
# rm -rf h5
# ymr.run --runargs "-n 2" ./h5.py --ranks 1 1 1 > /dev/null

parser = argparse.ArgumentParser()
parser.add_argument('--kbounds', type=float, default=0.0)
parser.add_argument('--ktwist', type=float, default=0.0)
parser.add_argument('--kbending', type=float, nargs=3, default=(0.0, 0.0, 0.0))
parser.add_argument('--l0_factor', type=float, default=1.0)
parser.add_argument('--tau0', type=float, default=0.0)
parser.add_argument('--tau0_eq', type=float, default=0.0)
parser.add_argument('--center_line', type=str, choices=["helix", "line"])
args = parser.parse_args()

ranks  = (1, 1, 1)
domain = [16, 16, 16]

dt = 1e-3

u = ymr.ymero(ranks, tuple(domain), dt, debug_level=8, log_filename='log', no_splash=True)

com_q = [[ 8., 8., 8.,    1.0, 0.0, 0.0, 0.0]]

L = 5.0
P = 1.0
R = 1.0

if args.center_line == "helix":
    def center_line(s):
        t = s * L * np.pi / P 
        return (R * np.cos(t),
                R * np.sin(t),
                (s-0.5) * L)

    def torsion(s):

#!/usr/bin/env python

import ymero as ymr
import numpy as np
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--restart", action='store_true', default=False)
args = parser.parse_args()

ranks  = (1, 1, 1)
domain = (4, 6, 8)

u = ymr.ymero(ranks, domain, dt=0, debug_level=3, log_filename='log', checkpoint_every = (5 if not args.restart else 0), no_splash=True)
    
pv = ymr.ParticleVectors.ParticleVector('pv', mass = 1)
u.registerParticleVector(pv=pv, ic=ymr.InitialConditions.Uniform(density=8))

coords = [[-1, -1, -1], [1, 1, 1]]
com_q = [[0.5 * domain[0], 0.5 * domain[1], 0.5 * domain[2],   1., 0, 0, 0]]
ov = ymr.ParticleVectors.RigidEllipsoidVector('ov', mass=1, object_size=len(coords), semi_axes=(1,1,1))
u.registerParticleVector(pv=ov, ic=ymr.InitialConditions.Rigid(com_q=com_q, coords=coords))

checker = ymr.BelongingCheckers.Ellipsoid('checker')
u.registerObjectBelongingChecker(checker, ov)
inner = u.applyObjectBelongingChecker(checker, pv, inside='inner')

if args.restart:
    u.restart("restart/")
u.run(7)

#!/usr/bin/env python

import numpy as np
import ymero as ymr

ranks  = (1, 1, 1)
domain = [4., 4., 4.]
density = 8

u = ymr.ymero(ranks, tuple(domain), dt=0, debug_level=3, log_filename='log')

pv = ymr.ParticleVectors.ParticleVector('pv', mass = 1)
ic = ymr.InitialConditions.UniformSphere(density=density, center=(2., 2., 2.), radius=2.0, inside=True)
u.registerParticleVector(pv=pv, ic=ic)

u.run(2)

if pv:
    icpos = pv.getCoordinates()
    icvel = pv.getVelocities()
    np.savetxt("pos.ic.txt", icpos)
    np.savetxt("vel.ic.txt", icvel)
    

# TEST: ic.uniform.sphere
# cd ic
# rm -rf pos*.txt vel*.txt
# ymr.run --runargs "-n 2" ./sphere.py > /dev/null
# paste pos.ic.txt vel.ic.txt | LC_ALL=en_US.utf8 sort > ic.out.txt

import trimesh

from mpi4py import MPI

parser = argparse.ArgumentParser()
parser.add_argument("--restart", action='store_true', default=False)
parser.add_argument("--ranks", type=int, nargs=3)
args = parser.parse_args()

comm   = MPI.COMM_WORLD
ranks  = args.ranks
domain = (16, 16, 16)
dt = 0

if args.restart:
    u = ymr.ymero(ranks, domain, dt, comm_ptr=MPI._addressof(comm), debug_level=8, log_filename='log', checkpoint_every=0)
else:
    u = ymr.ymero(ranks, domain, dt, comm_ptr=MPI._addressof(comm), debug_level=8, log_filename='log', checkpoint_every=5)

    
mesh = trimesh.creation.icosphere(subdivisions=1, radius = 0.1)
    
udx_mesh = ymr.ParticleVectors.MembraneMesh(mesh.vertices.tolist(), mesh.faces.tolist())
pv       = ymr.ParticleVectors.MembraneVector("pv", mass=1.0, mesh=udx_mesh)

if args.restart:
    ic   = ymr.InitialConditions.Restart("restart/")
else:
    nobjs = 10
    pos = [ np.array(domain) * t for t in np.linspace(0, 1.0, nobjs) ]
    Q = [ np.array([1.0, 0., 0., 0.])  for i in range(nobjs) ]