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