def check_BS_test_long(Ns=None):
dps = 64
results = {
8:
"0.5136878528165021745895011935069557781577860512538393575491621445983",
16:
"0.1779243262721065866057229914813588355640085932912539562135719013325"
}
if Ns is None: Ns = results.keys()
check = True
for N in Ns:
for p in ["multi", "amuse", "pp", "local", "proc"]:
h = BS_test(N=N,
processor=p,
dps=dps,
tend=1.,
prec='1.e-32',
res="x")
hr = h.__repr__()
if hr.find(results[N][:dps - 5]) >= 0:
pass
# print p+" ok"
else:
d = abs(h - mp.mpf(results[N])) / h
print d
print N, p + " mismatch, got:", hr, len(hr), float(
abs(mp.log10(d)))
if abs(d) > 10**(-dps + 5): check = False
return check
def check_kick(Ns=None):
dps = 64
results = {
16:
'0.5280968268833149585365524469736931751421937461245719231626600116459',
50:
'0.9570351506440379530178266489555425661480746175752162677540570048262',
64:
'-0.7561747845694916564830825081707286817639452371097957709612294389958',
150:
"-0.09344415268620983521705314736452944414180898050922914284511780006364",
256:
"-0.6293985589493140191821290296902117972778559732348390605690993188598",
350:
"0.735469970603869347834820970508731867404741985456426980852100139499",
512:
"0.9517024891436366308665374005000831926596595154320406804913855436092"
}
check = True
if Ns is None: Ns = results.keys()
for N in Ns:
for p in ["multi", "amuse", "pp", "local", "proc"]:
h = time_kick(N=N, processor=p, dps=dps)
hr = h.__repr__()
if hr.find(results[N]) >= 0:
pass
# print p+" ok"
else:
d = abs(h - mp.mpf(results[N])) / h
print N, p + " mismatch, got:", hr, len(hr), float(
abs(mp.log10(d)))
if d > 10**-dps: check = False
return check
def check_BS_test(Ns=None):
dps = 64
results = {
16:
"-0.2097788238899595006650143725272014434855335456003604589938999139641",
32:
"-0.2618649325481234815725778388341436310813732608134373611530832641849"
}
if Ns is None: Ns = results.keys()
check = True
for N in Ns:
for p in ["multi", "amuse", "pp", "local", "proc"]:
h = BS_test(N=N, processor=p, dps=dps)
hr = h.__repr__()
if hr.find(results[N][:dps - 5]) >= 0:
pass
# print p+" ok"
else:
d = abs((h - mp.mpf(results[N])) / h)
print d, h
print N, p + " mismatch, got:", hr, len(hr), float(
abs(mp.log10(d)))
if abs(d) > 10**(-dps + 5): check = False
return check
def commit_particles(self):
kwargs = self.kwargs.copy()
if "dps" not in kwargs:
kwargs["dps"] = max(int(-mp.log10(self.target_error) + 6), 15)
self.integrator = mp_adaptive_bulirschStoer(self.target_error,
**kwargs)
self.time = mp.mpf(self.time)
def __init__(self, m=0, x=0, y=0, z=0, vx=0, vy=0, vz=0):
self.m = mp.mpf(m)
self.x = mp.mpf(x)
self.y = mp.mpf(y)
self.z = mp.mpf(z)
self.vx = mp.mpf(vx)
self.vy = mp.mpf(vy)
self.vz = mp.mpf(vz)
def evolve_model(self, tend):
try:
self.integrator.evolve(mp.mpf(tend))
for i, key in enumerate(sorted(self.particles.keys())):
self.particles[key] = self.integrator.particles[i]
self._time = self.integrator.time
return 0
except Exception as ex:
print ex
return -1
def time_kick(N=16, processor="local", dps=64):
import time
from mp_integrator import kick
nproc = 4
nslices = nproc
if processor == "multi":
mp_integrator.pproc = MultiProcessor(preamble="import mp",
nslices=nslices,
pre_pickle=True,
nproc=nproc)
elif processor == "amuse":
mp_integrator.pproc = AmuseProcessor(hosts=[None] * nproc,
nslices=nslices,
preamble="import mp",
pre_pickle=True)
elif processor == "pp":
preamble = "import mp;from mp_integrator import _kick,_potential,_timestep,particle,jparticle"
mp_integrator.pproc = pp_Processor(preamble=preamble,
nslices=nslices,
pre_pickle=True)
elif processor == "proc":
mp_integrator.pproc = Processor(preamble="import mp")
else:
mp_integrator.pproc = Local_Processor()
mp.set_dps(dps)
mp_integrator.pproc.exec_("mp.set_dps(" + str(mp.dps) + ")")
parts = plummer(N)
dt = mp.mpf(1) / mp.mpf(8)
t1 = time.time()
kick(parts, parts, dt)
t2 = time.time()
print N, processor + " time:", t2 - t1
return parts[-1].vz
def copy_particles(parts):
copy = Particles(len(parts))
for i in range(len(parts)):
copy[i].m = mp.mpf(parts[i].m)
copy[i].x = mp.mpf(parts[i].x)
copy[i].y = mp.mpf(parts[i].y)
copy[i].z = mp.mpf(parts[i].z)
copy[i].vx = mp.mpf(parts[i].vx)
copy[i].vy = mp.mpf(parts[i].vy)
copy[i].vz = mp.mpf(parts[i].vz)
return copy
def set_state(self, index, mass, x, y, z, vx, vy, vz, radius):
try:
p = self.particles[index]
p.m = mp.mpf(mass)
p.x = mp.mpf(x)
p.y = mp.mpf(y)
p.z = mp.mpf(z)
p.vx = mp.mpf(vx)
p.vy = mp.mpf(vy)
p.vz = mp.mpf(vz)
return 0
except:
return -1
def aitkenneville(self, j, k, parts_jk, parts_j1k):
parts = Particles(len(parts_jk))
fac = 1 / ((self.nsequence(j) / mp.mpf(self.nsequence(j - k)))**2 - 1)
for i in range(len(parts_jk)):
parts[i].m = parts_jk[i].m
parts[i].x = parts_jk[i].x + fac * (parts_jk[i].x - parts_j1k[i].x)
parts[i].y = parts_jk[i].y + fac * (parts_jk[i].y - parts_j1k[i].y)
parts[i].z = parts_jk[i].z + fac * (parts_jk[i].z - parts_j1k[i].z)
parts[i].vx = parts_jk[i].vx + fac * (parts_jk[i].vx -
parts_j1k[i].vx)
parts[i].vy = parts_jk[i].vy + fac * (parts_jk[i].vy -
parts_j1k[i].vy)
parts[i].vz = parts_jk[i].vz + fac * (parts_jk[i].vz -
parts_j1k[i].vz)
return parts
def __init__(self):
self.particles = dict()
self._index_counter = 0
self._time = mp.mpf(0.)
self._begin_time = mp.mpf(0.)
self.processor = "Local_Processor()"
self.timestep_parameter = mp.mpf('1.')
self.epsilon_squared = mp.mpf('0.')
self.initial_target_error = mp.mpf("1.e-16")
self.factor = mp.mpf("1.e6")
self.integrator_method = "floating_point_exact"
self.initial_dps = 15
def rhombusrule(self, j, k, parts_jk, parts_j1k, parts_j1k1):
parts = Particles(len(parts_jk))
fac = (self.nsequence(j) / mp.mpf(self.nsequence(j - k)))**2
for i in range(len(parts_jk)):
parts[i].m = parts_jk[i].m
parts[i].x=parts_jk[i].x+(parts_jk[i].x-parts_j1k[i].x)/ \
(fac*(1-(parts_jk[i].x-parts_j1k[i].x)/(parts_jk[i].x-parts_j1k1[i].x))-1)
parts[i].y=parts_jk[i].y+(parts_jk[i].y-parts_j1k[i].y)/ \
(fac*(1-(parts_jk[i].y-parts_j1k[i].y)/(parts_jk[i].y-parts_j1k1[i].y))-1)
parts[i].z=parts_jk[i].z+(parts_jk[i].z-parts_j1k[i].z)/ \
(fac*(1-(parts_jk[i].z-parts_j1k[i].z)/(parts_jk[i].z-parts_j1k1[i].z))-1)
parts[i].vx=parts_jk[i].vx+(parts_jk[i].vx-parts_j1k[i].vx)/ \
(fac*(1-(parts_jk[i].vx-parts_j1k[i].vx)/(parts_jk[i].vx-parts_j1k1[i].vx))-1)
parts[i].vy=parts_jk[i].vy+(parts_jk[i].vy-parts_j1k[i].vy)/ \
(fac*(1-(parts_jk[i].vy-parts_j1k[i].vy)/(parts_jk[i].vy-parts_j1k1[i].vy))-1)
parts[i].vz=parts_jk[i].vz+(parts_jk[i].vz-parts_j1k[i].vz)/ \
(fac*(1-(parts_jk[i].vz-parts_j1k[i].vz)/(parts_jk[i].vz-parts_j1k1[i].vz))-1)
return parts
def __init__(self,
target_error,
coeff=[1.],
jmax=64,
rhombus=False,
fixed_j=0):
print "initializing bulirschStoer:", jmax, target_error, rhombus, fixed_j
self.target_error = target_error
self.nkickstep = 0
self.nkicks = 0
self.ndriftstep = 0
self.ndrift = 0
self.ntimecalls = 0
self.ntimes = 0
self.nstage = 2 * len(coeff) - 1
self.coeff = [mp.mpf(x) for x in (coeff + coeff[-2::-1])]
self.jmax = jmax if jmax > 8 else 8
self.jcount = 0
self.nsteps = 0
self.rhombus = rhombus
self.fixed_j = fixed_j
self.set_kick_drift_coeff()
def __init__(self, target_error=1.e-6, **kwargs):
self.time = mp.mpf(0.)
self.target_error = target_error
self.kwargs = kwargs
def __init__(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, mp.mpf(value))
def set_begin_time(self, t):
self._begin_time = mp.mpf(t)
return 0
def BS_test(N=16,
processor="local",
tend=1. / 8,
prec='1.e-16',
res="energy",
dps=64):
import time
nproc = 4
nslices = nproc
if processor == "multi":
mp_integrator.pproc = MultiProcessor(preamble="import mp",
nslices=nslices,
pre_pickle=True,
nproc=nproc)
elif processor == "amuse":
mp_integrator.pproc = AmuseProcessor(hosts=[None] * nproc,
nslices=nslices,
preamble="import mp",
pre_pickle=True)
elif processor == "pp":
preamble = "import mp;from mp_integrator import _kick,_potential,_timestep,particle,jparticle"
mp_integrator.pproc = pp_Processor(preamble=preamble,
nslices=nslices,
pre_pickle=True)
elif processor == "proc":
mp_integrator.pproc = Processor(preamble="import mp")
else:
mp_integrator.pproc = Local_Processor()
mp.set_dps(dps)
mp_integrator.pproc.exec_("mp.set_dps(" + str(mp.dps) + ")")
parts = plummer(N)
t = 0
tend = mp.mpf(tend)
dt = mp.mpf(1) / mp.mpf(8)
dt_param = mp.mpf('1.')
integrator = mp_adaptive_bulirschStoer(mp.mpf(prec), dt_param, dps=dps)
e0 = total_energy(parts)
x = [[part.x.__float__() for part in parts]]
y = [[part.y.__float__() for part in parts]]
z = [[part.z.__float__() for part in parts]]
t1 = time.time()
while t < tend:
t += dt
integrator.evolve(parts, dt)
print "t,de:", t, ((total_energy(parts) - e0) / e0).__float__()
x.append([part.x.__float__() for part in parts])
y.append([part.y.__float__() for part in parts])
z.append([part.z.__float__() for part in parts])
t2 = time.time()
e = total_energy(parts)
print 'de/e0:', ((e - e0) / e0).__float__()
print N, processor + ' runtime:', t2 - t1
print integrator.nsteps, integrator.jcount, integrator.jcount / float(
integrator.nsteps)
print integrator.nkickstep
"""
x=numpy.array(x)
y=numpy.array(y)
z=numpy.array(z)
c=['r','g','b','y','m','c','p']
for i in range(len(parts)):
pyplot.plot(x[:,i],y[:,i],c[i%7])
pyplot.xlim(-3,3)
pyplot.ylim(-3,3)
pyplot.savefig('test.png')
"""
# print x[-1],y[-1]
# print parts[0].x,total_energy(parts)
if res == "energy":
return total_energy(parts)
else:
return parts[0].x
def set_initial_target_error(self, t):
self.initial_target_error = mp.mpf(t)
return 0
def set_factor(self, t):
self.factor = mp.mpf(t)
return 0
def ec_BS_test():
import time
mp_integrator.pproc = MultiProcessor(nslices=4, pre_pickle=True)
# mp_integrator.pproc=AmuseProcessor(hosts=[None]*4,nslices=4,preamble="import mp",pre_pickle=True)
# mp_integrator.pproc=pp_Processor(nslices=4,pre_pickle=True)
# mp_integrator.pproc=Local_Processor()
mp.set_dps(64)
mp_integrator.pproc.exec_("mp.set_dps(" + str(mp.dps) + ")")
# parts=pythagorean()
# parts=two(mratio=1.e9)
parts = plummer(10)
# print parts[0].__module__
# raise
t = 0
tend = mp.mpf(.125)
dt = mp.mpf(1) / mp.mpf(8)
integrator = error_controlled_BS(mp.mpf('1.e-16'))
integrator.particles = parts
integrator.commit_particles()
e0 = total_energy(parts)
x = [[part.x.__float__() for part in parts]]
y = [[part.y.__float__() for part in parts]]
z = [[part.z.__float__() for part in parts]]
t1 = time.time()
while t < tend:
t += dt
integrator.evolve(t)
x.append([part.x.__float__() for part in integrator.particles])
y.append([part.y.__float__() for part in integrator.particles])
z.append([part.z.__float__() for part in integrator.particles])
t2 = time.time()
print "t,de:", t, ((total_energy(integrator.particles) - e0) /
e0).__float__(), t2 - t1
e = total_energy(integrator.particles)
print 'de/e0:', ((e - e0) / e0).__float__()
print 'runtime:', t2 - t1
# print integrator.nsteps,integrator.jcount,integrator.jcount/float(integrator.nsteps)
# print integrator.nkickstep
x = numpy.array(x)
y = numpy.array(y)
z = numpy.array(z)
c = ['r', 'g', 'b', 'y', 'm', 'c', 'p']
for i in range(len(integrator.particles)):
pyplot.plot(x[:, i], y[:, i], c[i % 7])
pyplot.xlim(-3, 3)
pyplot.ylim(-3, 3)
pyplot.savefig('test.png')
# print x[-1],y[-1]
print parts[0].x
def set_timestep_parameter(self, eta):
self.timestep_parameter = mp.mpf(eta)
return 0
def set_eps2(self, eps2):
self.epsilon_squared = mp.mpf(eps2)
return 0
