def test19(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test19"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) stars = Particles(2) stars[0].x = 1.0 | units.km stars[1].x = 2.0 | units.km binaries = Particles(1) binaries[0].y = 1.0 | units.km binaries[0].child1 = stars[0] binaries[0].child2 = stars[1] stars[0].parent = binaries[0] stars[1].parent = binaries[0] self.assertEqual(binaries[0].child1,stars[0]) self.assertEqual(binaries[0].child2,stars[1]) self.assertEqual(binaries[0].child1.parent,binaries[0]) self.assertEqual(binaries[0].child2.parent,binaries[0]) io.write_set_to_file([binaries,stars], output_file, "hdf5", names = ['binaries', 'children'], version = self.store_version()) loader_binaries, loaded_stars = io.read_set_from_file(output_file, "hdf5", names = ['binaries', 'children'], version = self.store_version()) self.assertEqual(loader_binaries[0].child1.key,stars[0].key) self.assertEqual(loader_binaries[0].child2.key,stars[1].key) self.assertEqual(loader_binaries[0].child1,loaded_stars[0]) self.assertEqual(loader_binaries[0].child2,loaded_stars[1]) self.assertEqual(loader_binaries[0].child1.parent,loader_binaries[0]) self.assertEqual(loader_binaries[0].child2.parent,loader_binaries[0])
def test9(self): p = datamodel.Particles(5) p.a = [1.0, 2.0, 3.0, 4.0, 5.0] p.b = [10, 11, 12, 13, 14] | units.m p.c = [20, 21, 22, 23, 24] | units.m io.write_set_to_file( p, "test.csv", "txt", attribute_names = ('a', 'b', 'c'), attribute_types = (None, units.m, units.m), maximum_number_of_lines_buffered = 1, ) with open("test.csv", "r") as f: contents = f.read() expected_contents = '#a b c\n#- m m\n1.0 10.0 20.0\n2.0 11.0 21.0\n3.0 12.0 22.0\n4.0 13.0 23.0\n5.0 14.0 24.0\n' self.assertEquals(expected_contents, contents) p2 = io.read_set_from_file( "test.csv", "txt", attribute_names = ('a', 'b', 'c'), attribute_types = (None, units.m, units.m), maximum_number_of_lines_buffered = 1, ) self.assertAlmostRelativeEquals(p2.a, p.a) self.assertAlmostRelativeEquals(p2.b, p.b) self.assertAlmostRelativeEquals(p2.c, p.c)
def test11(self): directory_name = os.path.dirname(__file__) filename = os.path.join(directory_name, 'gassphere_littleendian.dat') gas, halo, disk, bulge, stars, bndry = io.read_set_from_file(filename, format='gadget') self.assertEquals(len(gas), 1472) self.assertEquals(len(halo), 0) self.assertEquals(gas[0].key,1) self.assertEquals(gas[1].key,2) self.assertEquals(gas[2].key,3) self.assertEquals(gas[1471].key,1472) self.assertAlmostRelativeEquals(gas[0:5].x,[-0.0713372901082, 0.0713372901082, -0.21178227663, -0.0698266476393, 0.0698266476393] | nbody_system.length, 7) self.assertAlmostRelativeEquals(gas[0:5].u, [0.0500000007451, 0.0500000007451, 0.0500000007451, 0.0500000007451, 0.0500000007451] | (nbody_system.length / nbody_system.time)**2, 7 ) outputfilename = 'gadgettest.output' try: io.write_set_to_file((gas, halo, disk, bulge, stars, bndry), outputfilename, format='gadget', ids_are_long = False) gas, halo, disk, bulge, stars, bndry = io.read_set_from_file(outputfilename, format='gadget') self.assertEquals(len(gas), 1472) self.assertEquals(len(halo), 0) self.assertEquals(gas[0].key,1) self.assertEquals(gas[1].key,2) self.assertEquals(gas[2].key,3) self.assertEquals(gas[1471].key,1472) finally: if os.path.exists(outputfilename): os.remove(outputfilename)
def test9(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test9"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) number_of_particles = 10 p = Particles(number_of_particles) p.mass = [x * 2.0 for x in range(number_of_particles)] | units.kg p.model_time = 2.0 | units.s io.write_set_to_file( p, output_file, "hdf5", timestamp = 2 | units.Myr, scale = 1 | units.kg, version = self.store_version(), close_file = True ) loaded_particles = io.read_set_from_file( output_file, "hdf5", version = self.store_version() ) loaded_particles = self.get_version_in_store(loaded_particles) a = loaded_particles.collection_attributes self.assertAlmostRelativeEquals(a.timestamp, 2 | units.Myr) self.assertAlmostRelativeEquals(a.scale, 1 | units.kg)
def test10(self): p = datamodel.Particles(keys=[30,31,32,33,34]) p.a = [1.0, 2.0, 3.0, 4.0, 5.0] p.b = [10, 11, 12, 13, 14] | units.m p.c = [20, 21, 22, 23, 24] | units.m print p.key io.write_set_to_file( p, "test.csv", "txt", attribute_names = ('a', 'b', 'c'), attribute_types = (None, units.m, units.m), maximum_number_of_lines_buffered = 1, key_in_column = 0 ) with open("test.csv", "r") as f: contents = f.read() print repr(contents) expected_contents = '#a b c\n#- m m\n30 1.0 10.0 20.0\n31 2.0 11.0 21.0\n32 3.0 12.0 22.0\n33 4.0 13.0 23.0\n34 5.0 14.0 24.0\n' self.assertEquals(expected_contents, contents) p2 = io.read_set_from_file( "test.csv", "txt", attribute_names = ('a', 'b', 'c'), attribute_types = (None, units.m, units.m), maximum_number_of_lines_buffered = 1, key_in_column = 0 ) self.assertEquals(p2.key, p.key) self.assertAlmostRelativeEquals(p2.a, p.a) self.assertAlmostRelativeEquals(p2.b, p.b) self.assertAlmostRelativeEquals(p2.c, p.c)
def hybrid_self_gravitating_cluster(Ncl, Mstar, Rcl, t_end, dt, Mcut, filename): """ Create and evolve hybrid cluster; store data to file """ stars_superset, stars_below_cut, stars_above_cut, nbody_converter =\ create_cluster(Ncl, Mstar, Rcl, Mcut) bridge, channels = setup_codes(stars_below_cut, stars_above_cut, nbody_converter) time = 0. | units.Myr write_set_to_file(stars_superset.savepoint(time), filename, 'amuse', append_to_file=False) print "Saving data to", filename while time < (t_end - dt/2.): time += dt print "Evolving to", time # NB this is the solver, not the bridge when only one solver is used! # evolve_model, however, can be called both on bridge and solver (: bridge.evolve_model(time) channels.copy() write_set_to_file(stars_superset.savepoint(time), filename, 'amuse')
def main( star_mass = 1|units.MSun, star_radius = 1|units.RSun, disk_minumum_radius = 0.05 | units.AU, disk_maximum_radius = 10 | units.AU, disk_mass = 200 | MEarth, accurancy = 0.0001, planet_density = 3 | units.g/units.cm**3, output_filename = 'star.h5', seed = -1): if seed < 0: rng = random.RandomState() else: rng = random.RandomState(seed) output = new_system( star_mass, star_radius, disk_minumum_radius, disk_maximum_radius, disk_mass, accurancy, planet_density, rng = rng) star = output[0] print "Number of planets generated:", len(star.planets) print "Total mass:", star.planets.mass.sum().as_quantity_in(MEarth) for i, planet in enumerate(star.planets): print "Planet: {0: 3d} , mass: {1: 8.3f} MEarth, a: {2: 8.2f} AU".format(i, planet.mass.value_in(MEarth), planet.semimajor_axis.value_in(units.AU)) write_set_to_file(output, output_filename, 'hdf5', version="2.0",append_to_file = False)
def test11(self): print "Testing saving/loading timestamp in NEMO" x = datamodel.Particles(2) convert = nbody_system.nbody_to_si(1 | units.kg, 2 | units.m) x.mass = [1.0, 2.0] | units.kg x.position = [[1,2,3], [3,5,6]] | units.m x.velocity = [[1,2,3], [3,5,6]] | units.m / units.s current_time = 1.0 | units.Myr io.write_set_to_file(x.savepoint(current_time), "time_test_unit.tsf","tsf", nbody_to_si_converter = convert) y = io.read_set_from_file("time_test_unit.tsf","tsf", nbody_to_si_converter = convert) self.assertAlmostEquals(current_time, y.previous_state().get_timestamp(), 8, in_units=units.Myr) self.assertAlmostEquals(x.mass, y.mass, 8) self.assertAlmostEquals(x.position, y.position,8) self.assertAlmostEquals(x.velocity, y.velocity,8) x = datamodel.Particles(2) x.mass = [1.0, 2.0] | nbody_system.mass x.position = [[1,2,3], [3,5,6]] | nbody_system.length x.velocity = [[1,2,3], [3,5,6]] | nbody_system.speed current_time = 1.0 | nbody_system.time io.write_set_to_file(x.savepoint(current_time), "time_test_unit.tsf","tsf") y = io.read_set_from_file("time_test_unit.tsf","tsf") self.assertAlmostEquals(current_time, y.previous_state().get_timestamp(), 8, in_units=nbody_system.time) self.assertAlmostEquals(x.mass, y.mass, 8) self.assertAlmostEquals(x.position, y.position,8) self.assertAlmostEquals(x.velocity, y.velocity,8) os.remove("time_test_unit.tsf")
def make_galaxies(): if os.path.exists('disk_galactICs.amuse'): galaxy1 = read_set_from_file('disk_galactICs.amuse', 'amuse') else: halo_number_of_particles = NHALO converter = nbody_system.nbody_to_si( 1.0e9 | units.MSun, 1. | units.kpc) galaxy1 = new_galactics_model( halo_number_of_particles, disk_number_of_particles=NDISK, generate_bulge_flag=False, unit_system_converter=converter, disk_random_seed=12345) write_set_to_file(galaxy1, 'disk_galactICs.amuse', 'amuse') galaxy2 = Particles(len(galaxy1)) galaxy2.mass = galaxy1.mass galaxy2.position = galaxy1.position galaxy2.velocity = galaxy1.velocity galaxy1.rotate(0.0, numpy.pi/4, 0.0) galaxy2.rotate(numpy.pi/6, 0.0, 0.0) galaxy1.position += [100.0, 0, 0] | units.kpc galaxy2.position -= [100.0, 0, 0] | units.kpc galaxy1.velocity += [0.0, 50.0, 0] | units.km/units.s galaxy2.velocity -= [0.0, 50.0, 0] | units.km/units.s return galaxy1, galaxy2
def test5(self): x = datamodel.Particles(2) x.mass = [1.0, 2.0] | units.MSun x.radius = [3.0, 4.0] | units.RSun expected = [ "#mass radius\n#MSun RSun\n{0} 1.0 3.0\n{1} 2.0 4.0\n".format(x[0].key, x[1].key), "#mass radius\n#MSun RSun\n1.0 {0} 3.0\n2.0 {1} 4.0\n".format(x[0].key, x[1].key), "#mass radius\n#MSun RSun\n1.0 3.0 {0}\n2.0 4.0 {1}\n".format(x[0].key, x[1].key), ] for column_index, expected_content in enumerate(expected): io.write_set_to_file( x, "test.csv", "txt", key_in_column = column_index, attribute_types = (units.MSun, units.RSun) ) with open("test.csv", "r") as f: contents = f.read() self.assertEquals(expected_content, contents) y = io.read_set_from_file( "test.csv", "txt", key_in_column = column_index, attribute_types = (units.MSun, units.RSun), attribute_names = ('mass', 'radius') ) self.assertEquals(y[0], x[0]) self.assertEquals(y[1], x[1]) os.remove("test.csv")
def test58(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test58"+self.store_version()+".h5") if os.path.exists(output_file): os.remove(output_file) x = Particles(keys = (1,2)) x.mass = [1,2] | units.kg y = Particles(keys = (11,12,13,14)) y.mass = [40,50,60,70] | units.kg x.sub = None x[0].sub = y[0:2] y[0].sub = y[2:] io.write_set_to_file(x, output_file,"amuse", version=self.store_version()) z = io.read_set_from_file(output_file,"amuse") self.assertEqual(len(x), len(z)) self.assertEqual(len(x[0].sub), len(z[0].sub)) self.assertEqual(x[0].sub[0].sub.key, (13,14)) self.assertEqual(z[0].sub[0].sub.key, (13,14)) self.assertEqual(id(x[0].sub._original_set()), id(x[0].sub[0].sub._original_set())) # no more subsets, could this be fixed, would be very nice to do so # self.assertEqual(id(z[0].sub._original_set()), id(z[0].sub[0].sub._original_set())) self.assertTrue(z[1].sub==x[1].sub==None) os.remove(output_file)
def test16(self): import h5py print h5py.version.version print h5py test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test16"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) stars = Particles(2) stars[0].x = 1.0 | units.km stars[1].x = 2.0 | units.km stars[0].nn = stars[1] stars[1].nn = stars[0] self.assertEqual(stars[0].nn,stars[1]) self.assertEqual(stars[1].nn,stars[0]) io.write_set_to_file(stars, output_file, "hdf5", version = self.store_version()) processor = self.store_factory()(output_file, True, open_for_writing = True) loaded = processor.load() self.assertEqual(loaded[0].nn,loaded[1]) self.assertEqual(loaded[1].nn,loaded[0]) self.assertEqual(loaded[0].nn.key,stars[1].key) self.assertEqual(loaded[0].nn.x,stars[1].x)
def test17(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test17"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) stars = Particles(4) stars[0].x = 1.0 | units.km stars[1].x = 2.0 | units.km stars[2].x = 3.0 | units.km stars[3].x = 4.0 | units.km binaries = Particles(2) binaries[0].y = 1.0 | units.km binaries[1].y = 2.0 | units.km binaries[0].child1 = stars[0] binaries[0].child2 = stars[1] binaries[1].child1 = stars[2] binaries[1].child2 = stars[3] self.assertEqual(binaries[0].child1,stars[0]) self.assertEqual(binaries[1].child1,stars[2]) io.write_set_to_file(binaries, output_file, "hdf5", version = self.store_version()) loaded = io.read_set_from_file(output_file, "hdf5", version = self.store_version()) self.assertEqual(loaded[0].child1.key,stars[0].key) self.assertEqual(loaded[1].child1.key,stars[2].key)
def write_output(filename, parts, conv): particles_nbody = ParticlesWithUnitsConverted(parts, conv.as_converter_from_nbody_to_si()) #print particles_nbody write_set_to_file(particles_nbody, filename, "txt", attribute_names= ('rho', 'mass', 'x', 'y', 'z','vx', 'vy', 'vz')) return 0
def save_particles_to_file(bodies, bodies_to_save, bodies_filename,time,converter): #Add attributes that I'm interested in to the bodies_to_save bodies_to_save.position = converter.to_si(bodies.position).as_quantity_in(units.AU) bodies_to_save.velocity = converter.to_si(bodies.velocity).as_quantity_in(units.kms) bodies_to_save.semimajoraxis = converter.to_si(bodies.semimajoraxis).as_quantity_in(units.AU) bodies_to_save.eccentricity = bodies.eccentricity bodies_to_save.time = converter.to_si(time).as_quantity_in(units.yr) write_set_to_file(bodies_to_save, bodies_filename, "hdf5")
def test3(self): x = datamodel.Particles(2) x.mass = [1.0, 2.0] | units.MSun x.radius = [3.0, 4.0] | units.RSun io.write_set_to_file(x, "test.csv","txt", attribute_types = (units.MSun, units.RSun)) with open("test.csv", "r") as f: contents = f.read() self.assertEquals("#mass radius\n#MSun RSun\n1.0 3.0\n2.0 4.0\n", contents) os.remove("test.csv")
def evolve_disk_flyby(bodies, gravity, t_end, n_steps, converter, snap_dir, file_out): bodies = ParticlesSuperset([stars, planetesimals]) channel_from_gr_to_framework = gravity.particles.new_channel_to(bodies) rm_file(file_out) Etot_init = gravity.kinetic_energy + gravity.potential_energy Etot = Etot_init dt = t_end / float(n_steps) time = 0.0 | units.yr stdout = (file_out.split('.'))[0] stdout += '.txt' f = open(snap_dir + "/" + stdout, 'a') print " ** evolving: t_end = ", t_end, ", dt = ", dt.in_(units.yr) print " \t\t", "time", "\t\t", "dE" while time<=t_end: gravity.evolve_model(time) channel_from_gr_to_framework.copy() bodies.collection_attributes.timestamp = time Ekin = gravity.kinetic_energy Epot = gravity.potential_energy Etot = Ekin + Epot dE = Etot_init-Etot nb_E = converter.to_nbody(Etot) #nb_J = converter.nbody_length ** 2 * units.nbody_mass * units.nbody_time ** -2 # not supposed to work # A formatted string would work better than tabs. (Tabs never work) line = " \t" + str(time.value_in(units.yr)) + "\t" + str(nb_E) + "\t" + str(dE/Etot_init) print line f.write(line + "\n") # Write coordinates in Center of Mass frame # Move Stars to CoM (initially in CoM) #### The stars are already in CoM coordinates #### # Move planetesimals to CoM (initially in CoM) #### The stars are already in CoM coordinates #### (Does this mean the other method is wrong?) write_set_to_file(bodies, snap_dir + "/" + file_out, "hdf5") time += dt gravity.stop() return
def store_grids(self, grids, step): if __name__ == "__plot__": return grids_in_memory = [x.copy() for x in grids] io.write_set_to_file( grids_in_memory, "kelvin_helmholtz_{2}_{0}_{1}.vtu".format(self.number_of_grid_points, step, self.name_of_the_code), "vtu", is_multiple=True, )
def slowtest3(self): print "Generate a model for M31, using defaults (100k disk, 50k bulge, 200k halo) - Nbody units" halo_number_of_particles = 20000 particles = new_galactics_model(halo_number_of_particles, do_scale = True, bulge_number_of_particles=5000, disk_number_of_particles=10000) self.assertEquals(len(particles), 35000) self.assertAlmostEquals(particles.total_mass(), 1.0 | nbody_system.mass) self.assertAlmostEquals(particles.kinetic_energy(), 0.25 | nbody_system.energy) write_set_to_file(particles, os.path.join(get_path_to_results(), 'M31_galactICs.amuse'), 'amuse')
def test26(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test26"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) p = Grid(20) io.write_set_to_file(p, output_file, format='amuse', version = self.store_version()) os.remove(output_file)
def test23(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test23"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) particles = Particles() io.write_set_to_file(particles, output_file, format='amuse', version = self.store_version()) particles_from_file = io.read_set_from_file(output_file, format='amuse', version = self.store_version()) self.assertEquals(len(particles_from_file), 0)
def relax_in_isolation(giant_in_sph, sph_code, output_base_name): total_mass = giant_in_sph.gas_particles.total_mass() + giant_in_sph.core_particle.mass total_radius = max(giant_in_sph.gas_particles.position.lengths_squared()).sqrt() dynamical_timescale = (total_radius**3 / (2 * constants.G * total_mass)).sqrt().as_quantity_in(units.day) t_end = (10.0 * dynamical_timescale).as_quantity_in(units.day) n_steps = 100 hydro_code_options = dict(number_of_workers=2, redirection='file', redirect_file='hydrodynamics_code_relax_out.log') unit_converter = ConvertBetweenGenericAndSiUnits(total_radius, total_mass, t_end) hydrodynamics = sph_code(unit_converter, **hydro_code_options) hydrodynamics.parameters.epsilon_squared = giant_in_sph.core_radius**2 hydrodynamics.parameters.max_size_timestep = t_end hydrodynamics.parameters.time_max = 1.1 * t_end hydrodynamics.parameters.time_limit_cpu = 7.0 | units.day hydrodynamics.gas_particles.add_particles(giant_in_sph.gas_particles) hydrodynamics.dm_particles.add_particle(giant_in_sph.core_particle) potential_energies = hydrodynamics.potential_energy.as_vector_with_length(1).as_quantity_in(units.erg) kinetic_energies = hydrodynamics.kinetic_energy.as_vector_with_length(1).as_quantity_in(units.erg) thermal_energies = hydrodynamics.thermal_energy.as_vector_with_length(1).as_quantity_in(units.erg) print " Relaxing for", t_end, "(10 * dynamical timescale)" times = (t_end * range(1, n_steps+1) / n_steps).as_quantity_in(units.day) for i_step, time in enumerate(times): hydrodynamics.evolve_model(time) print " Relaxed for:", time potential_energies.append(hydrodynamics.potential_energy) kinetic_energies.append(hydrodynamics.kinetic_energy) thermal_energies.append(hydrodynamics.thermal_energy) hydrodynamics.gas_particles.copy_values_of_attributes_to( ['mass', 'x','y','z', 'vx','vy','vz', 'u', 'h_smooth'], giant_in_sph.gas_particles) giant_in_sph.core_particle.position = hydrodynamics.dm_particles[0].position giant_in_sph.core_particle.velocity = hydrodynamics.dm_particles[0].velocity hydrodynamics.stop() snapshotfile = output_base_name + "_gas.amuse" write_set_to_file(giant_in_sph.gas_particles, snapshotfile, format='amuse') shutil.copy(snapshotfile, os.path.join("..", "giant_models")) snapshotfile = output_base_name + "_core.amuse" # temporarily store core_radius on the core particle giant_in_sph.core_particle.radius = giant_in_sph.core_radius write_set_to_file(giant_in_sph.core_particle.as_set(), snapshotfile, format='amuse') giant_in_sph.core_particle.radius = 0.0 | units.m shutil.copy(snapshotfile, os.path.join("..", "giant_models")) energy_evolution_plot(times, kinetic_energies, potential_energies, thermal_energies, figname = output_base_name + "_energy_evolution.png")
def test10(self): print "Test 10: User interface (write_set_to_file and read_set_from_file)" particles = datamodel.Particles(2) particles.a = [1, 4] | units.none particles.b = [2, 5] | units.m particles.c = [3, 6] | units.kg / units.m**3 io.write_set_to_file(particles, "test_textio.csv","csv") read_particles = io.read_set_from_file("test_textio.csv", format = "csv") self.assertEquals(len(read_particles), 2) self.assertEquals(read_particles.a, [1, 4] | units.none) self.assertEquals(read_particles.b, [2, 5] | units.m) self.assertEquals(read_particles.c, [3, 6] | units.kg / units.m**3) os.remove("test_textio.csv")
def test29(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test29"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) particles = Grid(10) particles.attribute1 = "normal" particles.attribute2 = u"unicode" io.write_set_to_file(particles,output_file, format='amuse', version = self.store_version()) output = io.read_set_from_file(output_file, format='amuse') self.assertEquals(output[0].attribute2, u"unicode")
def test1(self): x = datamodel.Particles(2) x.mass = [1.0, 2.0] | nbody_system.mass x.radius = [3.0, 4.0] | nbody_system.length x.position = [[1,2,3], [3,5,6]] | nbody_system.length x.velocity = [[1,2,3], [3,5,6]] | nbody_system.speed io.write_set_to_file(x, "test.tsf","tsf") y = io.read_set_from_file("test.tsf","tsf") self.assertAlmostEquals(x.mass, y.mass, 8) # self.assertAlmostEquals(x.radius, y.radius, 8) self.assertAlmostEquals(x.position, y.position,8) self.assertAlmostEquals(x.velocity, y.velocity,8) os.remove("test.tsf")
def test59(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test59"+self.store_version()+".h5") if os.path.exists(output_file): os.remove(output_file) g=Grid(10,10) p=Particles(2) p[0].sub=g[0:5] io.write_set_to_file(p, output_file,"amuse", version=self.store_version()) z = io.read_set_from_file(output_file,"amuse") os.remove(output_file)
def hybrid_self_gravitating_cluster(Ncl, Mstar, Rcl, t_end, dt, Mcut, filename): stars_below_cut, stars_above_cut, nbody_converter =\ create_cluster(Ncl, Mstar, Rcl, Mcut) gravity_low_mass, gravity_high_mass, bridge, channels = \ setup_codes(stars_below_cut, stars_above_cut, nbody_converter) time = 0. | units.Myr write_set_to_file((stars_below_cut.savepoint(time), stars_above_cut.savepoint(time)), filename, 'amuse', names=("stars_below_cut", "stars_above_cut"), append_to_file=False) # Calculate initial energy Etot_init_low_mass = gravity_low_mass.kinetic_energy +\ gravity_low_mass.potential_energy Etot_init_high_mass = gravity_high_mass.kinetic_energy +\ gravity_high_mass.potential_energy Etot_init = Etot_init_low_mass + Etot_init_high_mass print "Saving data to", filename while time < (t_end - dt/2.): Etot_prev = Etot_init time += dt print "Evolving to", time bridge.evolve_model(time) channels.copy() # Calculate relative energy error Ekin_low_mass = gravity_low_mass.kinetic_energy Epot_low_mass = gravity_low_mass.potential_energy Etot_low_mass = Ekin_low_mass + Epot_low_mass Ekin_high_mass = gravity_high_mass.kinetic_energy Epot_high_mass = gravity_high_mass.potential_energy Etot_high_mass = Ekin_high_mass + Epot_high_mass Etot = Etot_low_mass + Etot_high_mass print "dE =", (Etot_init - Etot) / Etot, "ddE =",(Etot_prev - Etot) / Etot dE = (Etot_init - Etot) / Etot if isnan(dE): # numpy function dE = 0 # Save data write_set_to_file((stars_below_cut.savepoint(time), stars_above_cut.savepoint(time)), filename, 'amuse', names=("stars_below_cut", "stars_above_cut"))
def test2(self): x = datamodel.Particles(2) x.mass = [1.0, 2.0] | nbody_system.mass x.radius = [3.0, 4.0] | nbody_system.length x.position = [[1,2,3], [3,5,6]] | nbody_system.length x.velocity = [[1,2,3], [3,5,6]] | nbody_system.speed io.write_set_to_file(x, "test.dyn","dyn") y = io.read_set_from_file("test.dyn","dyn") self.assertAlmostEquals(x.mass, y.mass, 8) self.assertAlmostEquals(x.position, y.position,8) self.assertAlmostEquals(x.velocity, y.velocity,8) self.assertRaises(AttributeError, lambda: y.radius, expected_message = "You tried to access attribute 'radius' but this " "attribute is not defined for this set.") os.remove("test.dyn")
def test57(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test26"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) x = Particles(2) x.sub = None x[0].sub = Particles(2) io.write_set_to_file(x, output_file,"amuse", version=self.store_version()) y = io.read_set_from_file(output_file,"amuse") self.assertEqual(len(x), len(y)) self.assertEqual(len(x[0].sub), len(y[0].sub)) self.assertTrue(y[1].sub==x[1].sub==None) os.remove(output_file)
def test10(self): stellar_evolution = SSE() stellar_evolution.commit_parameters() stars = Particles(10) stars.mass = 1.0 | units.MSun stellar_evolution.particles.add_particles(stars) self.assertEquals(stellar_evolution.particles._factory_for_new_collection(), Particles) filename = os.path.join(get_path_to_results(), "test.h5") if os.path.exists(filename): os.remove(filename) io.write_set_to_file(stellar_evolution.particles, filename, 'hdf5') stored_stars = io.read_set_from_file(filename, 'hdf5') self.assertEquals(len(stars), len(stored_stars)) self.assertAlmostRelativeEquals(stars.mass, stored_stars.mass)
def test29(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test29" + self.store_version() + ".hdf5") if os.path.exists(output_file): os.remove(output_file) particles = Grid(10) particles.attribute1 = "normal" particles.attribute2 = "unicode" io.write_set_to_file(particles, output_file, format='amuse', version=self.store_version()) output = io.read_set_from_file(output_file, format='amuse') self.assertEqual(output[0].attribute2, "unicode")
def test5(self): print("Testing HDF5 io") if os.path.exists("test_unit.hdf5"): os.remove("test_unit.hdf5") x = datamodel.Particles(2) x.mass = [1.0, 2.0] | units.kg x.radius = [3.0, 4.0] | units.m x.position = [[1, 2, 3], [3, 5, 6]] | units.m x.velocity = [[1, 2, 3], [3, 5, 6]] | units.m / units.s io.write_set_to_file(x, "test_unit.hdf5", "hdf5") y = io.read_set_from_file("test_unit.hdf5", "hdf5") self.assertAlmostEqual(x.mass, y.mass, 8) self.assertAlmostEqual(x.radius, y.radius, 8) self.assertAlmostEqual(x.position, y.position, 8) self.assertAlmostEqual(x.velocity, y.velocity, 8) os.remove("test_unit.hdf5")
def test23(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test23" + self.store_version() + ".hdf5") if os.path.exists(output_file): os.remove(output_file) particles = Particles() io.write_set_to_file(particles, output_file, format='amuse', version=self.store_version()) particles_from_file = io.read_set_from_file( output_file, format='amuse', version=self.store_version()) self.assertEqual(len(particles_from_file), 0)
def slowtest3(self): print "Generate a model for M31, using defaults (100k disk, 50k bulge, 200k halo) - Nbody units" halo_number_of_particles = 20000 particles = new_galactics_model(halo_number_of_particles, do_scale=True, bulge_number_of_particles=5000, disk_number_of_particles=10000) self.assertEquals(len(particles), 35000) self.assertAlmostEquals(particles.total_mass(), 1.0 | nbody_system.mass) self.assertAlmostEquals(particles.kinetic_energy(), 0.25 | nbody_system.energy) write_set_to_file( particles, os.path.join(get_path_to_results(), 'M31_galactICs.amuse'), 'amuse')
def test11(self): particles = datamodel.Particles(2) particles.a = [1, 4] particles.b = [2, 5] | units.m particles.c = [3, 6] | units.kg / units.m**3 io.write_set_to_file(particles, "test_textio.csv", "csv", attribute_type=(None, units.kg / units.m**3, units.m), attribute_name=('a', 'c', 'b')) read_particles = io.read_set_from_file("test_textio.csv", format="csv") self.assertEquals(len(read_particles), 2) self.assertEquals(read_particles.a, [1, 4]) self.assertEquals(read_particles.b, [2, 5] | units.m) self.assertEquals(read_particles.c, [3, 6] | units.kg / units.m**3) os.remove("test_textio.csv")
def test3(self): x = datamodel.Particles(2) convert = nbody_system.nbody_to_si(1 | units.kg, 2 | units.m) x.mass = [1.0, 2.0] | units.kg x.radius = [3.0, 4.0] | units.m x.position = [[1,2,3], [3,5,6]] | units.m x.velocity = [[1,2,3], [3,5,6]] | units.m / units.s io.write_set_to_file(x, "test_unit.dyn","dyn", nbody_to_si_converter = convert) y = io.read_set_from_file("test_unit.dyn","dyn", nbody_to_si_converter = convert) self.assertAlmostEqual(x.mass, y.mass, 8) self.assertAlmostEqual(x.position, y.position,8) self.assertAlmostEqual(x.velocity, y.velocity,8) self.assertRaises(AttributeError, lambda: y.radius, expected_message = "You tried to access attribute 'radius' but this " "attribute is not defined for this set.") os.remove("test_unit.dyn")
def radhydro_evolve(sph, rad, tend, dt): """ evolve function to co-evolve sph under radiative feedback from rad the evolve proceeds as follows (a form of leapfrog integrator): - 1/2 step sph - update positions and densities in rad - full step rad transfer - update internal energies in sph - 1/2 step sph tend=end time dt=time step this function dump snapshots in file dump-.. """ i = 0 write_set_to_file(sph.gas_particles, "dump-%6.6i" % i, "amuse", append_to_file=False) t = 0. | units.Myr while t < tend - dt / 2: print t print "sph1" sph.evolve_model(t + dt / 2) print "rad" update_pos_rho(rad, sph.gas_particles) rad.evolve_model(t + dt) update_u(sph, rad.particles) print "sph2" sph.evolve_model(t + dt) t += dt i += 1 write_set_to_file(sph.gas_particles, "dump-%6.6i" % i, "amuse", append_to_file=False) sph.stop() rad.stop()
def test20(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test20"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) shape = 10, 10, 10 p = Grid(*shape) p.mass = (numpy.asarray([x * 2.0 for x in range(p.size)])).reshape(shape) io.write_set_to_file(p, output_file, "hdf5", version = self.store_version()) loaded = io.read_set_from_file(output_file, "hdf5", version = self.store_version()) loaded = self.get_version_in_store(loaded) self.assertAlmostRelativeEquals(p.mass[0][1][2], 24) self.assertAlmostRelativeEquals(p[0][1][2].mass, 24)
def generate_initial_conditions( number_of_stars = 10000, number_of_gas_particles = 2*10**6, star_formation_efficiency = 0.1, virial_radius = 0.33 | units.parsec, virial_ratio = 1.0, use_fractal = False): numpy.random.seed(12345678) seed_fractal = 312357271 masses = new_kroupa_mass_distribution(number_of_stars) total_stellar_mass = masses.sum() total_mass = total_stellar_mass / star_formation_efficiency converter = nbody_system.nbody_to_si(total_mass, virial_radius) if use_fractal: stars = new_fractal_cluster_model(number_of_stars, convert_nbody=converter, do_scale=False, fractal_dimension=1.6, random_seed=seed_fractal) else: stars = new_plummer_model(number_of_stars, convert_nbody=converter, do_scale=False) stars.mass = masses stars.move_to_center() print "scaling positions to match virial_radius" stars.position *= virial_radius / stars.virial_radius() print "scaling velocities to match virial_ratio" stars.velocity *= numpy.sqrt(virial_ratio * converter.to_si(0.5|nbody_system.energy) * star_formation_efficiency / stars.kinetic_energy()) print "new_gas_plummer_distribution" gas = new_gas_plummer_distribution( number_of_gas_particles, total_mass = (total_mass - total_stellar_mass), virial_radius = virial_radius, type = "fcc") gas.h_smooth = 0.0 | units.parsec filename = "YSC_{0}_stars{1}_gas{2}k_".format("fractal" if use_fractal else "plummer", number_of_stars, number_of_gas_particles/1000) print "Writing initial conditions to", filename, "+ stars/gas.amuse" write_set_to_file(stars, filename+"stars.amuse", "amuse", append_to_file=False) write_set_to_file(gas, filename+"gas.amuse", "amuse", append_to_file=False) with open(filename+"info.pkl", "wb") as outfile: cPickle.dump([converter], outfile) return stars, gas, filename
def test14(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test14"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) stars = Particles(2) stars.x = 1.0 | units.km stars.md = [[[1,3],[2,4],[3,5]],[[4,6],[5,7],[6,8]]] io.write_set_to_file(stars, output_file, "hdf5", version = self.store_version()) loaded = io.read_set_from_file(output_file, "hdf5", version = self.store_version()) self.assertEquals(loaded[0].md, [[1,3],[2,4],[3,5]]) self.assertEquals(loaded[1].md, [[4,6],[5,7],[6,8]]) self.assertEquals(loaded.md[0], [[1,3],[2,4],[3,5]]) self.assertEquals(loaded.md[1], [[4,6],[5,7],[6,8]])
def test10(self): stellar_evolution = SSE() stellar_evolution.commit_parameters() stars = Particles(10) stars.mass = 1.0 | units.MSun stellar_evolution.particles.add_particles(stars) self.assertEqual( stellar_evolution.particles._factory_for_new_collection(), Particles) filename = os.path.join(get_path_to_results(), "test.h5") if os.path.exists(filename): os.remove(filename) io.write_set_to_file(stellar_evolution.particles, filename, 'hdf5') stored_stars = io.read_set_from_file(filename, 'hdf5') self.assertEqual(len(stars), len(stored_stars)) self.assertAlmostRelativeEquals(stars.mass, stored_stars.mass)
def test30(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test30"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) particles = Particles(10) particles.mass = 10 | units.kg io.write_set_to_file(particles,output_file, format='amuse', version = self.store_version()) output = io.read_set_from_file(output_file, format='amuse', allow_writing = True) output.new_attribute= 2 * output.mass self.assertEquals(output.new_attribute, 2 * output.mass) output = output.iter_history().next() output.new_attribute= 2 * output.mass self.assertEquals(output.new_attribute, 2 * output.mass)
def test2(self): x = datamodel.Particles(2) x.mass = [1.0, 2.0] | nbody_system.mass x.radius = [3.0, 4.0] | nbody_system.length x.position = [[1, 2, 3], [3, 5, 6]] | nbody_system.length x.velocity = [[1, 2, 3], [3, 5, 6]] | nbody_system.speed io.write_set_to_file(x, "test.dyn", "dyn") y = io.read_set_from_file("test.dyn", "dyn") self.assertAlmostEquals(x.mass, y.mass, 8) self.assertAlmostEquals(x.position, y.position, 8) self.assertAlmostEquals(x.velocity, y.velocity, 8) self.assertRaises( AttributeError, lambda: y.radius, expected_message="You tried to access attribute 'radius' but this " "attribute is not defined for this set.") os.remove("test.dyn")
def evolve_system(system, t_end, n_steps): times = (t_end * range(1, n_steps+1) / n_steps).as_quantity_in(units.day) for i_step, time in enumerate(times): system.evolve_model(time) print " Evolved to:", time, figname = os.path.join("plots", "hydro_giant_{0:=04}.png".format(i_step)) print " - Hydroplot saved to: ", figname pynbody_column_density_plot(system.gas_particles, width=30|units.AU, vmin=26, vmax=33) scatter(system.dm_particles.x, system.dm_particles.y, c="w") pyplot.savefig(figname) pyplot.close() file_base_name = os.path.join("snapshots", "hydro_giant_{0:=04}_".format(i_step)) write_set_to_file(system.gas_particles, file_base_name+"gas.amuse", format='amuse') write_set_to_file(system.dm_particles, file_base_name+"dm.amuse", format='amuse') system.stop()
def test60(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test60"+self.store_version()+".h5") if os.path.exists(output_file): os.remove(output_file) x = Particles(2) x.mass = 1 | units.kg y = Particles(2) y.mass = 2 | units.kg io.write_set_to_file((x,y), output_file,"amuse", version=self.store_version(), names = ("x", "y")) z = io.read_set_from_file(output_file,"amuse") os.remove(output_file) self.assertTrue("x" in z) self.assertTrue("y" in z) self.assertAlmostRelativeEquals(z["x"].mass, 1 | units.kg) self.assertAlmostRelativeEquals(z["y"].mass, 2 | units.kg)
def test61(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test61"+self.store_version()+".h5") if os.path.exists(output_file): os.remove(output_file) x = Particles(10) x.mass = 1 | units.kg y = Particles(20) y.id = range(20) x[0].y = y[5:7] io.write_set_to_file(x, output_file,"amuse", version=self.store_version()) z = io.read_set_from_file(output_file,"amuse") self.assertEquals(x[0].y[0].id, 5) self.assertEquals(z[0].y[0].id, 5) os.remove(output_file)
def test13(self): p = datamodel.Particles(100) p.a = numpy.arange(0, 1, 0.01) | units.m path = os.path.abspath( os.path.join(self.get_path_to_results(), "test.csv")) io.write_set_to_file(p, path, "amuse-txt", attribute_names=('a'), maximum_number_of_lines_buffered=10, key_in_column=0) p2 = io.read_set_from_file(path, "txt", maximum_number_of_lines_buffered=10, key_in_column=0) self.assertEquals(p2.key, p.key) self.assertAlmostRelativeEquals(p2.a, p.a)
def test12(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test12"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) shape = 10, 10, 10 p = Grid(*shape) p.mass = ([x * 2.0 for x in range(p.size)] | units.kg).reshape(shape) p.model_time = 2.0 | units.s io.write_set_to_file(p.savepoint(timestamp = 2 | units.Myr, scale = 1 | units.kg), output_file, "hdf5", version = self.store_version()) loaded_particles = io.read_set_from_file(output_file, "hdf5", version = self.store_version()) loaded_particles = self.get_version_in_store(loaded_particles) a = loaded_particles.collection_attributes self.assertAlmostRelativeEquals(a.timestamp, 2 | units.Myr) self.assertAlmostRelativeEquals(a.scale, 1 | units.kg)
def slowtest4(self): print "Generate a model for a disk galaxy (10k disk, no bulge, 20k halo) - SI units" halo_number_of_particles = 20000 converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits(constants.G, 1.0e12 | units.MSun, 50.0 | units.kpc) particles = new_galactics_model(halo_number_of_particles, disk_number_of_particles=10000, generate_bulge_flag=False, do_scale=True, unit_system_converter=converter) self.assertEquals(len(particles), 30000) self.assertAlmostRelativeEquals(particles.total_mass(), 1.0e12 | units.MSun, 10) self.assertAlmostRelativeEquals(particles.kinetic_energy(), converter.to_si(0.25 | nbody_system.energy), 10) disk = particles[:10000] self.assertAlmostRelativeEquals(disk.total_mass(), 2.156e10 | units.MSun, 3) self.assertAlmostRelativeEquals(disk.position.lengths_squared().amax().sqrt().in_(units.kpc), 15.584 | units.kpc, 3) self.assertAlmostRelativeEquals(disk.position.std(axis=0).in_(units.kpc), [3.5934, 3.6768, 0.17078] | units.kpc, 3) write_set_to_file(particles, os.path.join(get_path_to_results(), 'disk_galactICs.amuse'), 'amuse')
def test11(self): p = datamodel.Particles(200) p.a = 2 | units.m io.write_set_to_file(p, "test.csv", "txt", attribute_names=('a'), attribute_types=(units.m, ), maximum_number_of_lines_buffered=10, key_in_column=0) p2 = io.read_set_from_file("test.csv", "txt", attribute_names=('a'), attribute_types=(units.m, ), maximum_number_of_lines_buffered=10, key_in_column=0) self.assertEquals(p2.key, p.key) self.assertAlmostRelativeEquals(p2.a, p.a)
def test11(self): print "Testing saving/loading timestamp in NEMO" x = datamodel.Particles(2) convert = nbody_system.nbody_to_si(1 | units.kg, 2 | units.m) x.mass = [1.0, 2.0] | units.kg x.position = [[1, 2, 3], [3, 5, 6]] | units.m x.velocity = [[1, 2, 3], [3, 5, 6]] | units.m / units.s current_time = 1.0 | units.Myr io.write_set_to_file(x.savepoint(current_time), "time_test_unit.tsf", "tsf", nbody_to_si_converter=convert) y = io.read_set_from_file("time_test_unit.tsf", "tsf", nbody_to_si_converter=convert) self.assertAlmostEquals(current_time, y.previous_state().get_timestamp(), 8, in_units=units.Myr) self.assertAlmostEquals(x.mass, y.mass, 8) self.assertAlmostEquals(x.position, y.position, 8) self.assertAlmostEquals(x.velocity, y.velocity, 8) x = datamodel.Particles(2) x.mass = [1.0, 2.0] | nbody_system.mass x.position = [[1, 2, 3], [3, 5, 6]] | nbody_system.length x.velocity = [[1, 2, 3], [3, 5, 6]] | nbody_system.speed current_time = 1.0 | nbody_system.time io.write_set_to_file(x.savepoint(current_time), "time_test_unit.tsf", "tsf") y = io.read_set_from_file("time_test_unit.tsf", "tsf") self.assertAlmostEquals(current_time, y.previous_state().get_timestamp(), 8, in_units=nbody_system.time) self.assertAlmostEquals(x.mass, y.mass, 8) self.assertAlmostEquals(x.position, y.position, 8) self.assertAlmostEquals(x.velocity, y.velocity, 8) os.remove("time_test_unit.tsf")
def evolve_system(coupled_system, t_end, n_steps): times = (t_end * range(1, n_steps + 1) / n_steps).as_quantity_in(units.day) hydro = coupled_system.codes[ 0].code # only calculate potential energy for the giant (SPH particles) potential_energies = hydro.potential_energy.as_vector_with_length( 1).as_quantity_in(units.J) kinetic_energies = hydro.kinetic_energy.as_vector_with_length( 1).as_quantity_in(units.J) thermal_energies = hydro.thermal_energy.as_vector_with_length( 1).as_quantity_in(units.J) giant = coupled_system.particles giant_initial_position = giant.center_of_mass() giant_initial_velocity = giant.center_of_mass_velocity() for i_step, time in enumerate(times): giant.position += giant_initial_position - giant.center_of_mass() giant.velocity = (giant.velocity - giant.center_of_mass_velocity()) * ( i_step * 1.0 / n_steps) + giant_initial_velocity print " Evolving...", coupled_system.evolve_model(time) print " Evolved to:", time, potential_energies.append(hydro.potential_energy) kinetic_energies.append(hydro.kinetic_energy) thermal_energies.append(hydro.thermal_energy) print " Energies calculated" density_plot(coupled_system, i_step) snapshotfile = "hydro_giant_gas.amuse" write_set_to_file(coupled_system.gas_particles, snapshotfile, format='amuse') snapshotfile = "hydro_giant_dm.amuse" write_set_to_file(coupled_system.dm_particles, snapshotfile, format='amuse') coupled_system.stop() energy_evolution_plot(times[:len(kinetic_energies) - 1], kinetic_energies, potential_energies, thermal_energies)
def test16(self): convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km) smalln = SmallN(convert_nbody) smalln.initialize_code() smalln.dt_dia = 5000 stars = self.new_system_of_sun_and_earth() moon = datamodel.Particle() moon.mass = units.kg(7.3477e22) moon.radius = units.km(1737.10) moon.position = units.km(numpy.array((149.5e6 + 384.399, 0.0, 0.0))) moon.velocity = units.ms(numpy.array((0.0, 29800 + 1022, 0.0))) stars.add_particle(moon) earth = stars[1] smalln.particles.add_particles(stars) smalln.evolve_model(365.0 | units.day) smalln.update_particle_tree() smalln.update_particle_set() self.assertEqual(len(smalln.particles), 5) self.assertEarthAndMoonWasDetectedAsBinary(smalln.particles, stars) inmemory = smalln.particles.copy() self.assertEarthAndMoonWasDetectedAsBinary(inmemory, stars) test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "newsmalln-test16.hdf5") if os.path.exists(output_file): os.remove(output_file) io.write_set_to_file(smalln.particles, output_file, "hdf5") fromfile = io.read_set_from_file(output_file, "hdf5") self.assertEarthAndMoonWasDetectedAsBinary(fromfile, stars) smalln.stop()
def test19(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test19" + self.store_version() + ".hdf5") if os.path.exists(output_file): os.remove(output_file) stars = Particles(2) stars[0].x = 1.0 | units.km stars[1].x = 2.0 | units.km binaries = Particles(1) binaries[0].y = 1.0 | units.km binaries[0].child1 = stars[0] binaries[0].child2 = stars[1] stars[0].parent = binaries[0] stars[1].parent = binaries[0] self.assertEqual(binaries[0].child1, stars[0]) self.assertEqual(binaries[0].child2, stars[1]) self.assertEqual(binaries[0].child1.parent, binaries[0]) self.assertEqual(binaries[0].child2.parent, binaries[0]) io.write_set_to_file([binaries, stars], output_file, "hdf5", names=['binaries', 'children'], version=self.store_version()) loader_binaries, loaded_stars = io.read_set_from_file( output_file, "hdf5", names=['binaries', 'children'], version=self.store_version()) self.assertEqual(loader_binaries[0].child1.key, stars[0].key) self.assertEqual(loader_binaries[0].child2.key, stars[1].key) self.assertEqual(loader_binaries[0].child1, loaded_stars[0]) self.assertEqual(loader_binaries[0].child2, loaded_stars[1]) self.assertEqual(loader_binaries[0].child1.parent, loader_binaries[0]) self.assertEqual(loader_binaries[0].child2.parent, loader_binaries[0])
def test59(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test59" + self.store_version() + ".h5") if os.path.exists(output_file): os.remove(output_file) g = Grid(10, 10) p = Particles(2) p[0].sub = g[0:5] io.write_set_to_file(p, output_file, "amuse", version=self.store_version()) z = io.read_set_from_file(output_file, "amuse") os.remove(output_file)
def test22(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test22"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) stars = Particles(2) stars.x = 1.0 | units.km overlay = ParticlesOverlay(stars) overlay.y = 2.0 | units.km io.write_set_to_file(overlay, output_file, "hdf5", version = self.store_version()) loaded = io.read_set_from_file(output_file, "hdf5", close_file = True, version = self.store_version()) self.assertEquals(loaded[0].x, 1.0 | units.km) self.assertEquals(loaded[1].y, 2.0 | units.km)
def test7(self): print("Testing HDF5 io with a ParticlesSuperset") if os.path.exists("test_unit.hdf5"): os.remove("test_unit.hdf5") set1 = datamodel.Particles(2) set2 = datamodel.Particles(2) superset = datamodel.ParticlesSuperset([set1, set2]) superset.mass = [1.0, 2.0, 3.0, 4.0] | units.kg superset.radius = [3.0, 4.0, 5.0, 6.0] | units.m superset.position = [[1,2,3], [3,5,6], [3,2,1], [-3,-5,-6]] | units.m superset.velocity = [[1,2,3], [3,5,6], [3,2,1], [-3,-5,-6]] | units.m / units.s io.write_set_to_file(superset, "test_unit.hdf5","hdf5") y = io.read_set_from_file("test_unit.hdf5","hdf5") self.assertAlmostEqual(superset.mass, y.mass, 8) self.assertAlmostEqual(superset.radius, y.radius, 8) self.assertAlmostEqual(superset.position, y.position,8) self.assertAlmostEqual(superset.velocity, y.velocity,8) os.remove("test_unit.hdf5")
def test28(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test28" + self.store_version() + ".hdf5") if os.path.exists(output_file): os.remove(output_file) stars = Particles(2) stars[0].x = 1.0 | units.km stars[1].x = 2.0 | units.km binaries = Particles(1) binaries[0].y = 1.0 | units.km binaries[0].child1 = stars[0] binaries[0].child2 = stars[1] stars[0].parent = binaries[0] stars[1].parent = binaries[0] self.assertEqual(binaries[0].child1, stars[0]) self.assertEqual(binaries[0].child2, stars[1]) self.assertEqual(binaries[0].child1.parent, binaries[0]) self.assertEqual(binaries[0].child2.parent, binaries[0]) io.write_set_to_file(binaries, output_file, "hdf5", version=self.store_version()) with io.read_set_from_file(output_file, "hdf5", version=self.store_version(), return_context=True) as loaded: self.assertEqual(loaded[0].child1.key, stars[0].key) self.assertEqual(loaded[0].child2.key, stars[1].key) self.assertEqual(loaded[0].child1, stars[0]) self.assertEqual(loaded[0].child2, stars[1]) self.assertEqual(loaded[0].child1.parent, loaded[0]) self.assertEqual(loaded[0].child2.parent, loaded[0])
def test57(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test26" + self.store_version() + ".hdf5") if os.path.exists(output_file): os.remove(output_file) x = Particles(2) x.sub = None x[0].sub = Particles(2) io.write_set_to_file(x, output_file, "amuse", version=self.store_version()) y = io.read_set_from_file(output_file, "amuse") self.assertEqual(len(x), len(y)) self.assertEqual(len(x[0].sub), len(y[0].sub)) self.assertTrue(y[1].sub == x[1].sub == None) os.remove(output_file)
def test53(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test53"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) stars = Particles(2) stars[0].x = 1.0 | units.km stars[1].x = 2.0 | units.km gas = Grid(2,3) gas.y = [[1.0, 2.0, 3.0], [4.0,5.0,6.0]] | units.km stars[0].gas = gas io.write_set_to_file(stars, output_file, "hdf5", version = self.store_version()) loaded_stars = io.read_set_from_file(output_file, "hdf5", version = self.store_version()) self.assertAlmostRelativeEquals(loaded_stars[0].gas[0][0].y,1.0 | units.km) self.assertAlmostRelativeEquals(loaded_stars[0].gas[0][2].y,3.0 | units.km) self.assertEquals(loaded_stars[1].gas, None)