def test5(self): print "Testing MI6 evolve_model, 2 particles, no SMBH" particles = Particles(2) particles.mass = 1.0 | units.MSun particles.radius = 1.0 | units.RSun particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0]] | units.AU particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0] ] | units.km / units.s particles[1].vy = (constants.G * (2.0 | units.MSun) / (2.0 | units.AU)).sqrt() particles.move_to_center() print particles converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU) instance = MI6(converter, **default_options) instance.initialize_code() instance.parameters.smbh_mass = 0.0 | units.MSun instance.commit_parameters() instance.particles.add_particles(particles) instance.commit_particles() primary = instance.particles[0] P = 2 * math.pi * primary.x / primary.vy position_at_start = primary.position.x instance.evolve_model(P / 4.0) self.assertAlmostRelativeEqual(position_at_start, primary.position.y, 3) instance.evolve_model(P / 2.0) self.assertAlmostRelativeEqual(position_at_start, -primary.position.x, 3) instance.evolve_model(P) self.assertAlmostRelativeEqual(position_at_start, primary.position.x, 3) instance.cleanup_code() instance.stop()
def create_initial_wind_for_time(self, time, check_length=True): """ Particles are created as if the wind has already been blowing for 'time'. Note that this does not work if the mass loss is derived from stellar evolution. """ self.model_time = time self.particles.evolve_mass_loss(self.model_time) if self.has_new_wind_particles(): wind_gas = self.create_wind_particles() if self.has_target(): self.target_gas.add_particles(wind_gas) elif check_length: raise AmuseException("create_initial_wind time was too small to" "create any particles.") else: wind_gas = Particles() self.reset() return wind_gas
def test2(self): m_star = 0.666 | units.MSun a_min = 666. | units.AU a_max = 6666. | units.AU q_min = 6. | units.AU cloud = new_isotropic_cloud(66, m_star=m_star, a_min=a_min, a_max=a_max, q_min=q_min) binary = Particles(1) binary[0].mass = m_star binary[0].position = (0., 0., 0.) | units.AU binary[0].velocity = (0., 0., 0.) | units.kms for comet in cloud: binary.add_particle(comet) mass1, mass2, semimajor_axis, eccentricity, true_anomaly, inclination, long_asc_node, arg_per = \ orbital_elements_from_binary(binary, G=constants.G) print mass1, mass2, semimajor_axis, eccentricity, true_anomaly, inclination, long_asc_node, arg_per self.assertTrue(a_min < semimajor_axis < a_max) self.assertTrue(q_min < semimajor_axis * (1. - eccentricity)) binary.remove_particle(comet)
def copy_results(self, instance): if self.name_of_the_code in self.sph_hydro_codes: n_samples = self.number_of_grid_points * 3 result = Particles(n_samples) result.position = [(x, 0.5, 0.5) | length for x in numpy.linspace(0.0, 1.0, n_samples)] x, y, z = result.x, result.y, result.z if self.name_of_the_code == "fi": x -= (0.5 | length) y -= (0.5 | length) z -= (0.5 | length) no_speed = [0.0] * n_samples | speed result.rho, result.rhovx, result.rhovy, result.rhovz, result.energy = [ self.convert_generic_units.to_generic(quantity) for quantity in instance.get_hydro_state_at_point( x, y, z, no_speed, no_speed, no_speed) ] else: result = [] for x in instance.itergrids(): result.append(x.copy()) return result
def test14b(self): print("Testing basic operations: evolve_one_step and evolve_for (on subset)") stars = Particles(2) stars.mass = 1.0 | units.MSun instance = SSE() se_stars = instance.particles.add_particles(stars) self.assertAlmostEqual(se_stars.age, [0.0, 0.0] | units.yr) for i in range(3): se_stars[:1].evolve_one_step() self.assertAlmostEqual(se_stars.age, [1650.46953688, 0.0] | units.Myr, 3) number_of_steps = 10 step_size = se_stars[0].age / number_of_steps for i in range(1, number_of_steps + 1): se_stars[1:].evolve_for(step_size) self.assertAlmostEqual(se_stars.age, [number_of_steps, i] * step_size) print(se_stars) self.assertAlmostRelativeEqual(se_stars[0].age, se_stars[1].age) self.assertAlmostRelativeEqual(se_stars[0].luminosity, se_stars[1].luminosity, 3) self.assertAlmostRelativeEqual(se_stars[0].radius, se_stars[1].radius, 3) self.assertAlmostRelativeEqual(se_stars[0].temperature, se_stars[1].temperature, 3) instance.stop()
def test1(self): print "Test basic particle attributes and scale_to_standard - nbody units" particles = Particles(2) particles.position = [[-1, 0, 0], [1, 0, 0]] | nbody_system.length particles.velocity = [[-1, 0, 0], [1, 0, 0] ] | nbody_system.length / nbody_system.time particles.mass = 0.4 | nbody_system.mass self.assertAlmostRelativeEquals(particles.total_mass(), 0.8 | nbody_system.mass) self.assertAlmostRelativeEquals(particles.kinetic_energy(), 0.4 | nbody_system.energy) self.assertAlmostRelativeEquals( particles.potential_energy(G=nbody_system.G), -0.08 | nbody_system.energy) self.assertAlmostRelativeEquals(particles.virial_radius(), 4.0 | nbody_system.length) particles.scale_to_standard() self.assertAlmostRelativeEquals(particles.total_mass(), 1.0 | nbody_system.mass) self.assertAlmostRelativeEquals(particles.kinetic_energy(), 0.25 | nbody_system.energy) self.assertAlmostRelativeEquals( particles.potential_energy(G=nbody_system.G), -0.5 | nbody_system.energy) self.assertAlmostRelativeEquals(particles.virial_radius(), 1.0 | nbody_system.length) particles.scale_to_standard(virial_ratio=1) # unbound self.assertAlmostRelativeEquals(particles.kinetic_energy(), 0.5 | nbody_system.energy) self.assertAlmostRelativeEquals( particles.potential_energy(G=nbody_system.G), -0.5 | nbody_system.energy) particles.scale_to_standard(virial_ratio=0) # velocities zeroed self.assertAlmostRelativeEquals(particles.kinetic_energy(), 0 | nbody_system.energy) self.assertAlmostRelativeEquals( particles.potential_energy(G=nbody_system.G), -0.5 | nbody_system.energy)
def test56(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) 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 gas = Grid(2, 3) gas.y = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] | units.km io.write_set_to_file(p, output_file, "hdf5", particle=p[1], particles=p, gridpoint=gas[0][0], grid=gas, version=self.store_version()) loaded_particles = io.read_set_from_file(output_file, "hdf5", version=self.store_version(), copy_history=False, close_file=False) attributes = loaded_particles.collection_attributes self.assertAlmostRelativeEquals(attributes.particle.mass, loaded_particles[1].mass) self.assertEquals(attributes.particle.key, loaded_particles[1].key) self.assertEquals(id(attributes.particles), id(loaded_particles)) self.assertAlmostRelativeEquals(attributes.gridpoint.y, 1.0 | units.km) self.assertAlmostRelativeEquals(attributes.grid[0][0].y, 1.0 | units.km)
def test7(self): test_results_path = self.get_path_to_results() output_file = os.path.join(test_results_path, "test7"+self.store_version()+".hdf5") if os.path.exists(output_file): os.remove(output_file) instance = self.store_factory()(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 instance.store(p) instance.close() instance = self.store_factory()(output_file) loaded_particles = self.get_version_in_store(instance.load()) loaded_particles.mass = [x * 3.0 for x in range(number_of_particles)] | units.kg previous_mass_in_kg = [x * 3.0 for x in range(number_of_particles)] instance.close() instance = self.store_factory()(output_file) loaded_particles = instance.load() loaded_mass_in_kg = loaded_particles.mass.value_in(units.kg) for expected, actual in zip(previous_mass_in_kg, loaded_mass_in_kg): self.assertEquals(expected, actual) instance.close() instance = self.store_factory()(output_file) loaded_particles = self.get_version_in_store(instance.load()) loaded_particles[2].mass = 44 | units.kg instance.close() instance = self.store_factory()(output_file) loaded_particles = self.get_version_in_store(instance.load()) self.assertEquals( 44 | units.kg, loaded_particles[2].mass) instance.close()
def test11(self): print "Test that a source is not included when calculating gravity on itself." number_of_sources = 100 mass, length, G = nbody_system.mass, nbody_system.length, nbody_system.G sources = Particles(mass=numpy.ones(number_of_sources) | mass, x=0 | length, y=0 | length, z=0 | length) point = Particle(x=0 | length, y=0 | length, z=1.0 | length) instance = self.new_fastkick_instance() instance.particles.add_particles(sources) potential = instance.get_potential_at_point(0 | length, point.x, point.y, point.z) ax, ay, az = instance.get_gravity_at_point(0 | length, point.x, point.y, point.z) self.assertAlmostEqual(ax, G * (0 | mass / length**2), 5) self.assertAlmostEqual(ay, G * (0 | mass / length**2), 5) self.assertAlmostRelativeEqual(az, -G * sources.total_mass() / point.z**2, 3) self.assertAlmostRelativeEqual(potential, -G * sources.total_mass() / point.z, 3) point.mass = 1e6 | mass instance.particles.add_particle(point) potential = instance.get_potential_at_point(0 | length, point.x, point.y, point.z) ax, ay, az = instance.get_gravity_at_point(0 | length, point.x, point.y, point.z) self.assertAlmostEqual(ax, G * (0 | mass / length**2), 5) self.assertAlmostEqual(ay, G * (0 | mass / length**2), 5) self.assertAlmostRelativeEqual(az, -G * sources.total_mass() / point.z**2, 3) self.assertAlmostRelativeEqual(potential, -G * sources.total_mass() / point.z, 3) instance.stop()
def test7(self): instance = self.new_fastkick_instance() instance.parameters.epsilon_squared = 0.00001 | nbody_system.length**2 particles = Particles(2) particles.mass = [1.0, 1.0] | nbody_system.mass particles.position = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0] ] | nbody_system.length instance.particles.add_particles(particles) zero = 0.0 | nbody_system.length ax, ay, az = instance.get_gravity_at_point(zero, 1.0 | nbody_system.length, zero, zero) self.assertAlmostEqual(ax, 0.0 | nbody_system.acceleration, 6) self.assertAlmostEqual(ay, 0.0 | nbody_system.acceleration, 6) self.assertAlmostEqual(az, 0.0 | nbody_system.acceleration, 6) for x in (0.25, 0.5, 0.75): x0 = x | nbody_system.length x1 = (2.0 - x) | nbody_system.length potential0 = instance.get_potential_at_point(zero, x0, zero, zero) potential1 = instance.get_potential_at_point(zero, x1, zero, zero) ax0, ay0, az0 = instance.get_gravity_at_point(zero, x0, zero, zero) ax1, ay1, az1 = instance.get_gravity_at_point(zero, x1, zero, zero) self.assertAlmostEqual(ay0, 0.0 | nbody_system.acceleration, 6) self.assertAlmostEqual(az0, 0.0 | nbody_system.acceleration, 6) self.assertAlmostEqual(ay1, 0.0 | nbody_system.acceleration, 6) self.assertAlmostEqual(az1, 0.0 | nbody_system.acceleration, 6) self.assertAlmostEqual(ax0, -ax1, 5) ax = (-1.0 / (x0**2) + 1.0 / (x1**2)) * (1.0 | nbody_system.length**3 / nbody_system.time**2) self.assertAlmostEqual(ax, ax0, 2) self.assertAlmostEqual(potential0, potential1, 5) instance.stop()
def initialize_multiple_system(N_bodies, masses, semimajor_axis, eccentricity, inclination, argument_of_pericenter, longitude_of_ascending_node): N_binaries = N_bodies - 1 particles = Particles(N_bodies + N_binaries) for index in range(N_bodies): particle = particles[index] particle.mass = masses[index] particle.is_binary = False particle.radius = 1.0 | units.RSun particle.child1 = None particle.child2 = None for index in range(N_binaries): particle = particles[index + N_bodies] particle.is_binary = True particle.semimajor_axis = semimajor_axis[index] particle.eccentricity = eccentricity[index] particle.inclination = inclination[index] particle.argument_of_pericenter = argument_of_pericenter[index] particle.longitude_of_ascending_node = longitude_of_ascending_node[ index] # Specify the `2+2' hierarchy: if index == 0: particle.child1 = particles[0] particle.child2 = particles[1] elif index == 1: particle.child1 = particles[2] particle.child2 = particles[3] elif index == 2: particle.child1 = particles[4] particle.child2 = particles[5] binaries = particles[particles.is_binary] return particles, binaries
def test3(self): particles = Particles(10) particles.mass = list(range(10)) | units.kg particles[0].child1 = particles[1] particles[0].child2 = particles[2] particles[1].child1 = particles[3] particles[1].child2 = particles[4] particles[2].child1 = particles[5] particles[2].child2 = particles[6] tree = particles.as_binary_tree() self.assertFalse(tree.is_leaf()) self.assertEqual(len(list(tree.iter_children())), 4) self.assertEqual(len(list(tree.iter_branches())), 1) self.assertEqual(len(list(tree.iter_leafs())), 3) self.assertEqual(len(list(tree.iter_descendant_leafs())), 7) self.assertEqual(len(list(tree.iter_descendant_branches())), 3) branches = list(tree.iter_branches()) self.assertEqual(len(list(branches[0].iter_children())), 2) self.assertEqual(len(list(branches[0].iter_branches())), 2) self.assertEqual(len(list(branches[0].iter_leafs())), 0) self.assertEqual(len(list(branches[0].iter_descendant_leafs())), 4) self.assertEqual(len(list(branches[0].iter_descendant_branches())), 2)
def evolve_with_kepler(self, hydro): if self.verbose: print "evolve_with_kepler" indices_two_most_massive = self.stars_after_encounter.mass.argsort( )[-2:] groups = [ self.groups_after_encounter[i] for i in indices_two_most_massive ] old_particles = self.stars_after_encounter[indices_two_most_massive] new_particles = Particles(2) new_particles.mass = old_particles.mass new_particles[0].position, new_particles[ 0].velocity = self.skip_to_relative_position_velocity new_particles.move_to_center() for group, old_particle, new_particle in zip(groups, old_particles, new_particles): in_hydro = group.get_intersecting_subset_in(hydro.gas_particles) if self.verbose: print in_hydro.center_of_mass().as_quantity_in( units.RSun), old_particle.position.as_quantity_in( units.RSun), new_particle.position.as_quantity_in( units.RSun) in_hydro.position += new_particle.position - old_particle.position in_hydro.velocity += new_particle.velocity - old_particle.velocity
def wind_sphere(self, star, Ngas): wind = Particles(Ngas) dt = (self.model_time - star.wind_release_time) if self.critical_timestep is None or dt > self.critical_timestep: acc_function = self.acc_function else: acc_function = ConstantVelocityAcceleration(use_initial=True) outer_wind_distance = acc_function.radius_from_time(dt, star) wind.position, direction = self.generate_positions( Ngas, star.radius, outer_wind_distance, acc_function.radius_from_number, star=star) velocities = acc_function.velocity_from_radius(wind.position.lengths(), star) wind.velocity = direction * self.as_three_vector(velocities) return wind
def test3(self): print "Test CollisionHandler with collision code class, arguments and parameters" colliders = Particles(2) handler = CollisionHandler( CollisionCodeForTesting, collision_code_arguments=dict(next_mass=5|units.kg), collision_code_parameters=dict(mass_unit=units.g) ) result = handler.handle_collision(colliders[0], colliders[1]) self.assertTrue(isinstance(result, Particles)) self.assertEqual(result.mass, 5 | units.kg) self.assertTrue(result.mass.unit is units.g) result = handler.handle_collision(colliders[0], colliders[1]) self.assertEqual(result.mass, 5 | units.kg) self.assertTrue(result.mass.unit is units.g) handler.collision_code_arguments = dict(next_mass=42|units.kg) handler.collision_code_parameters = dict(mass_unit=units.MSun) result = handler.handle_collision(colliders[0], colliders[1]) self.assertEqual(result.mass, 42 | units.kg) self.assertTrue(result.mass.unit is units.MSun)
def new_plummer_spatial_distribution(number_of_particles, total_mass = 1.0|nbody_system.mass, virial_radius = 1.0|nbody_system.length, mass_cutoff = 0.999, **keyword_arguments): # optional arguments for UniformSphericalDistribution """ Returns a Particles set with positions following a Plummer distribution. Only the positions and masses (equal-mass system) are set. """ particles = Particles(number_of_particles) particle_mass = total_mass * 1.0 / number_of_particles particles.mass = particle_mass x, y, z = UniformSphericalDistribution( number_of_particles, mass_cutoff=mass_cutoff, **keyword_arguments).result # Now scale the uniformly distributed particle positions to match the radial density profile r_old = numpy.sqrt(x*x + y*y + z*z) scale_factor = (0.1875 * numpy.pi * virial_radius.number) / numpy.sqrt(1.0 - r_old**2) particles.x = scale_factor * x | virial_radius.unit particles.y = scale_factor * y | virial_radius.unit particles.z = scale_factor * z | virial_radius.unit return particles
def test7(self): print("Test: evolve particles one at a time.") print( "Used to be problematic, since initial_mass of idle particle is set to zero." ) stars = Particles(2) stars.mass = 1.0 | units.MSun for star in stars: stellar_evolution = SSE() stellar_evolution.commit_parameters() stellar_evolution.particles.add_particles(star.as_set()) stellar_evolution.commit_particles() from_stellar_evolution_to_model = stellar_evolution.particles.new_channel_to( star.as_set()) stellar_evolution.evolve_model() from_stellar_evolution_to_model.copy() stellar_evolution.stop() self.assertEqual(stars[0].initial_mass, stars[1].initial_mass) self.assertEqual(stars[0].luminosity, stars[1].luminosity) self.assertEqual(stars[0].age, stars[1].age) print( "Solved: SSE_muse_interface.f sets initial_mass to mass when necessary." )
def test3(self): print "Testing sun recreation" instance = EVtwin() instance.initialize_code() instance.commit_parameters() stars = Particles(1) stars.mass = 1 | units.MSun instance.particles.add_particles(stars) instance.commit_particles() self.assertEquals(instance.particles.mass, 1 | units.MSun) self.assertAlmostEquals(instance.particles.luminosity, 0.7098065 | units.LSun, 6) self.assertAlmostEquals(instance.particles.radius, 0.8892833 | units.RSun, 6) instance.evolve_model(4.8|units.Gyr) self.assertAlmostEquals(instance.particles.mass, 0.999921335 | units.MSun, 6) self.assertAlmostEquals(instance.particles.luminosity, 1.04448714 | units.LSun, 6) self.assertAlmostEquals(instance.particles.radius, 1.02061451 | units.RSun, 6) instance.stop()
def create_binary(m1, m2, a, e, i, g, h): particles = Particles(3) for index in range(2): particle = particles[index] particle.is_binary = False if index == 0: particle.mass = m1 else: particle.mass = m2 particle.child1 = None particle.child2 = None particles[2].is_binary = True particles[2].semimajor_axis = a particles[2].eccentricity = e particles[2].inclination = i particles[2].argument_of_pericenter = g particles[2].longitude_of_ascending_node = h particles[2].child1 = particles[0] particles[2].child2 = particles[1] return particles
def wind_sphere(self, star, Ngas): wind = Particles(Ngas) wind_velocity = star.initial_wind_velocity outer_wind_distance = star.radius + wind_velocity * ( self.model_time - star.wind_release_time) if self.r_max is not None and outer_wind_distance < self.r_max: outer_wind_distance = self.r_max wind.position, direction = self.generate_positions( Ngas, star.radius, outer_wind_distance) if self.compensate_gravity: r = wind.position.lengths() escape_velocity_squared = 2. * constants.G * star.mass / r speed = (wind_velocity**2 + escape_velocity_squared).sqrt() wind.velocity = self.as_three_vector(speed) * direction else: wind.velocity = direction * wind_velocity return wind
def test2(self): """ Test Spheroid sink accretion """ particles = self.create_particle_grid() spheroid = sink.Spheroid([5., 4., 1.]|units.RSun) sink_particles = Particles(1, mass=10.|units.MSun, radius=0.|units.RSun, position=[[1., 1., 1.]]|units.RSun) sinks = new_sink_particles(sink_particles, shapes=spheroid) accreted = sinks.accrete(particles) self.assertEqual(len(accreted), 161) self.assertEqual(len(particles), 1839) self.assertEqual(accreted.x.max(), 4|units.RSun) self.assertEqual(accreted.y.max(), 3|units.RSun) self.assertEqual(accreted.z.max(), 0.5|units.RSun) spheroid.dimensions[2] = 3 | units.RSun accreted = sinks.accrete(particles) self.assertEqual(len(accreted), 324) self.assertEqual(len(particles), 1515) self.assertEqual(accreted.x.max(), 4|units.RSun) self.assertEqual(accreted.y.max(), 3|units.RSun) self.assertEqual(accreted.z.max(), 2.5|units.RSun) self.assertIsSubvector([3, 2, 2.5]|units.RSun, particles.position)
def add_comets(star, m_comets, n_comets, q_min, q_max, a_min, a_max, seed): cloud_xyz = generate_primordial_oort_cloud(star.mass, n_comets, q_min, q_max, a_min, a_max, seed) masses = new_salpeter_mass_distribution(n_comets, 0.1|units.MSun, 100|units.MSun) masses = m_comets*masses/masses.sum() print("total mass in comets: M=", masses.sum().in_(units.MEarth)) comets = Particles(n_comets) comets.mass = masses comets.name = "comet" comets.type = "comet" comets.host = star comets.x = cloud_xyz[:,2] | units.au comets.y = cloud_xyz[:,3] | units.au comets.z = cloud_xyz[:,4] | units.au comets.vx = cloud_xyz[:,5] | 2*numpy.pi*units.au/units.yr comets.vy = cloud_xyz[:,6] | 2*numpy.pi*units.au/units.yr comets.vz = cloud_xyz[:,7] | 2*numpy.pi*units.au/units.yr comets.position += star.position comets.velocity += star.velocity return comets
def test12(self): print "Testing adding and removing particles from stellar evolution code..." particles = Particles(3) particles.mass = 1.0 | units.MSun instance = MOSSE() instance.initialize_code() instance.commit_parameters() self.assertEquals(len(instance.particles), 0) # before creation instance.particles.add_particles(particles[:-1]) instance.commit_particles() instance.evolve_model(1.0 | units.Myr) self.assertEquals(len(instance.particles), 2) # before remove self.assertAlmostEqual(instance.particles.age, 1.0 | units.Myr) instance.particles.remove_particle(particles[0]) self.assertEquals(len(instance.particles), 1) instance.evolve_model(2.0 | units.Myr) self.assertAlmostEqual(instance.particles[0].age, 2.0 | units.Myr) instance.particles.add_particles(particles[::2]) self.assertEquals(len(instance.particles), 3) # it's back... self.assertAlmostEqual(instance.particles[0].age, 2.0 | units.Myr) self.assertAlmostEqual(instance.particles[1].age, 0.0 | units.Myr) self.assertAlmostEqual(instance.particles[2].age, 0.0 | units.Myr) # ... and rejuvenated. instance.evolve_model( 3.0 | units.Myr ) # The young stars keep their age offset from the old star self.assertAlmostEqual(instance.particles.age, [3.0, 1.0, 1.0] | units.Myr) instance.evolve_model(4.0 | units.Myr) self.assertAlmostEqual(instance.particles.age, [4.0, 2.0, 2.0] | units.Myr) instance.stop()
def test14(self): print "Testing EVtwin states" stars = Particles(2) stars.mass = 1.0 | units.MSun instance = EVtwin() print "First do everything manually:", self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.initialize_code() self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.commit_parameters() self.assertEquals(instance.get_name_of_current_state(), 'EDIT') instance.particles.add_particle(stars[0]) instance.commit_particles() self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.cleanup_code() self.assertEquals(instance.get_name_of_current_state(), 'END') instance.stop() print "ok" print "initialize_code(), commit_parameters(), (re)commit_particles(), " \ "and cleanup_code() should be called automatically:", instance = EVtwin() self.assertEquals(instance.get_name_of_current_state(), 'UNINITIALIZED') instance.parameters.RGB_wind_setting = -0.5 self.assertEquals(instance.get_name_of_current_state(), 'INITIALIZED') instance.particles.add_particle(stars[0]) self.assertEquals(instance.get_name_of_current_state(), 'EDIT') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.particles.add_particle(stars[1]) self.assertEquals(instance.get_name_of_current_state(), 'UPDATE') mass = instance.particles[0].mass self.assertEquals(instance.get_name_of_current_state(), 'RUN') instance.stop() self.assertEquals(instance.get_name_of_current_state(), 'STOPPED') print "ok"
def xslowtest11(self): print "Test 11: Continue the stellar evolution of a 'merger product' - WIP" instance = EVtwin() instance.initialize_code() instance.commit_parameters() instance.parameters.min_timestep_stop_condition = 1.0 | units.s stars = Particles(3) stars.mass = [1.0, 2.0, 1.0] | units.MSun instance.particles.add_particles(stars) instance.commit_particles() instance.evolve_model(1.0 | units.Myr) stellar_models = instance.native_stars.get_internal_structure() self.assertEqual(len(stellar_models), 3) self.assertEqual(len(stellar_models[0]), 199) self.assertEqual(len(stellar_models[1]), 199) self.assertAlmostEqual(stellar_models[0].mass[198], 1.0 | units.MSun, 2) self.assertAlmostEqual(stellar_models[1].mass[198], 2.0 | units.MSun, 2) self.assertAlmostEqual(stellar_models[0].mass[0], 0.0 | units.MSun, 2) instance.new_particle_from_model(stellar_models[0], instance.particles[0].age) self.assertEqual(len(instance.particles), 4) self.assertEqual(len(instance.imported_stars), 1) imported_stellar_model = instance.imported_stars[0].get_internal_structure() self.assertEqual(len(imported_stellar_model), 199) self.assertAlmostEqual(imported_stellar_model.mass[198], 1.0 | units.MSun, 2) self.assertAlmostEqual(imported_stellar_model.mass[0], 0.0 | units.MSun, 2) self.assertAlmostRelativeEqual(imported_stellar_model.X_H, stellar_models[0].X_H, 5) self.assertAlmostRelativeEqual(imported_stellar_model.X_He, stellar_models[0].X_He, 5) self.assertAlmostRelativeEqual(imported_stellar_model.mass, stellar_models[0].mass, 2) self.assertAlmostRelativeEqual(imported_stellar_model.radius[1:], stellar_models[0].radius[1:], 2) # instance.evolve_model(2.0 | units.Myr) print instance.particles instance.stop() del instance
def create_triple(m1, m2, m3, a_in, a_out, e_in, e_out, i_in, i_out, g_in, g_out, h_in, h_out): N_bodies = 3 N_binaries = 2 m_list = [m1, m2, m3] a_list = [a_in, a_out] e_list = [e_in, e_out] i_list = [i_in, i_out] g_list = [g_in, g_out] h_list = [h_in, h_out] particles = Particles(N_bodies + N_binaries) for index in range(N_bodies): particle = particles[index] particle.is_binary = False particle.mass = m_list[index] particle.child1 = None particle.child2 = None for index in range(N_binaries): particles[index + N_bodies].is_binary = True particles[index + N_bodies].semimajor_axis = a_list[index] particles[index + N_bodies].eccentricity = e_list[index] particles[index + N_bodies].inclination = i_list[index] particles[index + N_bodies].argument_of_pericenter = g_list[index] particles[index + N_bodies].longitude_of_ascending_node = h_list[index] if index == 0: particles[index + N_bodies].child1 = particles[0] particles[index + N_bodies].child2 = particles[1] elif index == 1: particles[index + N_bodies].child1 = particles[2] particles[index + N_bodies].child2 = particles[3] return particles
def test3(self): print( "Testing SinkParticles initialization from existing particles in set" ) particles = Particles(10) self.assertRaises( AttributeError, SinkParticles, particles[[4, 7]], expected_message= "You tried to access attribute 'radius' but this attribute is not defined for this set." ) particles.radius = 42.0 | units.RSun particles.mass = list(range(1, 11)) | units.MSun particles.position = [[i, 2 * i, 3 * i] for i in range(10)] | units.parsec sinks = SinkParticles(particles[[4]]) self.assertEqual(sinks.mass, 5.0 | units.MSun) self.assertEqual(sinks.sink_radius, 42.0 | units.RSun) self.assertEqual(sinks.radius, 42.0 | units.RSun) self.assertEqual(sinks.position, [4.0, 8.0, 12.0] | units.parsec) sinks = SinkParticles(particles[[4, 7]], sink_radius=[1, 2] | units.AU) self.assertEqual(sinks.sink_radius, [1.0, 2.0] | units.AU) self.assertEqual(sinks.radius, 42.0 | units.RSun) self.assertEqual(sinks.mass, [5.0, 8.0] | units.MSun) self.assertEqual(sinks.position, [[4, 8, 12], [7, 14, 21]] | units.parsec) self.assertEqual( set([ 'key', 'mass', 'radius', 'x', 'y', 'z', 'sink_radius', 'vx', 'vy', 'vz', 'lx', 'ly', 'lz' ]), set(str(sinks).split("\n")[0].split())) self.assertEqual(set(['key', 'mass', 'radius', 'x', 'y', 'z']), set(str(particles).split("\n")[0].split()))
def test2(self): print("Demonstrate new_sink_particles usage") cloud = Particles(100) cloud.mass = 1 | units.MSun cloud.position = [[0, 0, 0], [100, 100, 100], [200, 200, 200], [300, 300, 300]]*25 | units.parsec cloud.velocity = [[0, 0, 0], [1, 1, 1]]*50 | units.km / units.s unit_converter = ConvertBetweenGenericAndSiUnits(1|units.m, 1|units.kg, 1|units.s) sph_code = Stub(unit_converter) sph_code.parameters.stopping_condition_maximum_density = 1 | units.kg / units.m**3 sph_code.gas_particles.add_particles(cloud) density_limit_detection = sph_code.stopping_conditions.density_limit_detection density_limit_detection.enable() sph_code.evolve_model(1 | units.Myr) self.assertTrue(density_limit_detection.is_set()) self.assertEqual(len(density_limit_detection.particles()), 3) self.assertEqual(density_limit_detection.particles().position, [[100, 100, 100], [200, 200, 200], [300, 300, 300]] | units.parsec) print(density_limit_detection.particles()) clumps = density_limit_detection.particles().copy() sph_code.gas_particles.remove_particles(clumps) sinks = new_sink_particles(clumps, sink_radius=1|units.parsec,looping_over=self.looping_over) self.assertEqual(sinks.sink_radius, 1.0 | units.parsec) self.assertEqual(sinks.mass, 1.0 | units.MSun) self.assertEqual(sinks.position, [[100, 100, 100], [200, 200, 200], [300, 300, 300]] | units.parsec) self.assertEqual(len(sph_code.gas_particles), 97) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass() + clumps.total_mass(), 100 | units.MSun, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), 97 | units.MSun, 10) sinks.accrete(sph_code.gas_particles) self.assertAlmostRelativeEqual(sinks.mass, [25, 25, 25] | units.MSun, 10) self.assertEqual(len(sph_code.gas_particles), 25) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass() + clumps.total_mass(), 100 | units.MSun, 10) self.assertAlmostRelativeEqual(sph_code.gas_particles.total_mass(), 25 | units.MSun, 10)
def split_subcodes(self): subsystems = self.particles.compound_particles() to_remove = Particles() sys_to_add = [] for parent in subsystems: subsys = parent.subsystem radius = parent.radius components = subsys.connected_components(threshold=self.threshold, distfunc=self.distfunc) if len(components) > 1: #print("splitting:", len(components)) parentposition = parent.position parentvelocity = parent.velocity to_remove.add_particle(parent) for c in components: sys = c.copy() sys.position += parentposition sys.velocity += parentvelocity sys_to_add.append(sys) code = self.subcodes.pop(parent) del code if len(to_remove) > 0: self.particles.remove_particles(to_remove) for sys in sys_to_add: if len(sys) > 1: newcode = self.subcode_factory(sys) newcode.parameters.begin_time = self.model_time newcode.particles.add_particles(sys) newparent = self.particles.add_subsystem(newcode.particles) newparent.sub_worker_radius = 0. * newparent.radius self.subcodes[newparent] = newcode else: newparent = self.particles.add_subsystem(sys) newparent.sub_worker_radius = sys[0].radius self.set_parent_particle_radius(newparent)
def evolve_bridged_orbit_in_potential(potential, cluster, code, timestep, current_age): orbit = static_potentials.Position_In_Potential(potential, cluster) bridge, gravity, gravity_to_orbit = setup_bridge( potential, cluster, current_age, timestep, orbit, code) print(current_age, "->", orbit.particle.position) # Evolving backward gravity.particles.velocity *= -1 while bridge.model_time < current_age - (timestep / 2.): # print bridge.model_time, "-", gravity.particles.position[0] bridge.evolve_model(bridge.model_time + timestep) gravity_to_orbit.copy() gravity.particles.velocity *= -1 gravity.model_time = 0 | units.Myr bridge.time = 0 | units.Myr cluster = gravity.particles[0] orbit.particle = cluster bridge, gravity, gravity_to_orbit = setup_bridge( potential, cluster, current_age, timestep, orbit, code) print(bridge.model_time, "->", orbit.particle.position) # Evolving forward full_orbit = Particles() while bridge.model_time < current_age - (timestep / 2.): full_orbit.add_particle(orbit.particle.copy()) bridge.evolve_model(bridge.model_time + timestep) gravity_to_orbit.copy() full_orbit.add_particle(orbit.particle.copy()) print(bridge.model_time, "->", orbit.particle.position) full_orbit.position -= coordinate_correction return full_orbit